From d394ce15f779fad5aeb4b39b0b65b3c340329162 Mon Sep 17 00:00:00 2001 From: AdoAdoAdo Date: Tue, 19 Jul 2022 18:25:41 +0300 Subject: [PATCH 01/10] add a multi signer container for versioned multisigner --- cmd/node/config/enableEpochs.toml | 6 + config/config.go | 6 + config/epochConfig.go | 1 + config/tomlConfig_test.go | 16 +++ consensus/mock/consensusDataContainerMock.go | 2 +- consensus/spos/bls/export_test.go | 2 +- consensus/spos/bls/subroundEndRound.go | 2 +- consensus/spos/bls/subroundSignature.go | 4 +- consensus/spos/bls/subroundStartRound.go | 2 +- consensus/spos/consensusCore.go | 10 +- consensus/spos/consensusCoreValidator.go | 2 +- consensus/spos/consensusCoreValidator_test.go | 4 +- consensus/spos/consensusCore_test.go | 4 +- consensus/spos/interface.go | 4 +- .../disabled/disabledMultiSignerContainer.go | 24 ++++ .../epochStartInterceptorsContainerFactory.go | 2 +- errors/errors.go | 6 + factory/consensus/consensusComponents.go | 2 +- factory/crypto/cryptoComponents.go | 63 ++++----- factory/crypto/cryptoComponentsHandler.go | 42 ++++-- .../crypto/cryptoComponentsHandler_test.go | 41 +++--- factory/crypto/cryptoComponents_test.go | 4 +- factory/crypto/export_test.go | 9 +- factory/crypto/multiSignerContainer.go | 133 ++++++++++++++++++ factory/interface.go | 11 +- factory/mock/components/default.go | 24 ++-- factory/mock/cryptoComponentsMock.go | 78 +++++----- factory/processing/processComponents.go | 2 +- go.mod | 2 +- go.sum | 4 +- integrationTests/consensus/testInitializer.go | 2 +- integrationTests/mock/cryptoComponentsStub.go | 78 +++++----- .../multiShard/hardFork/hardFork_test.go | 2 +- integrationTests/testProcessorNode.go | 30 ++-- node/mock/factory/cryptoComponentsStub.go | 74 ++++++---- node/nodeRunner.go | 1 + .../baseInterceptorsContainerFactory.go | 6 +- .../metaInterceptorsContainerFactory_test.go | 3 +- .../shardInterceptorsContainerFactory_test.go | 13 +- process/headerCheck/headerSignatureVerify.go | 25 ++-- .../factory/argInterceptedDataFactory.go | 2 +- .../interceptedMetaHeaderDataFactory_test.go | 10 +- process/interface.go | 10 +- process/mock/cryptoComponentsMock.go | 56 ++++---- scripts/testnet/variables.sh | 6 +- .../cryptoMocks/multiSignerContainerMock.go | 23 +++ update/factory/exportHandlerFactory.go | 8 +- update/factory/fullSyncInterceptors.go | 6 +- 48 files changed, 587 insertions(+), 280 deletions(-) create mode 100644 epochStart/bootstrap/disabled/disabledMultiSignerContainer.go create mode 100644 factory/crypto/multiSignerContainer.go create mode 100644 testscommon/cryptoMocks/multiSignerContainerMock.go diff --git a/cmd/node/config/enableEpochs.toml b/cmd/node/config/enableEpochs.toml index aaddfdbf513..f7ca5cda302 100644 --- a/cmd/node/config/enableEpochs.toml +++ b/cmd/node/config/enableEpochs.toml @@ -218,6 +218,12 @@ # MiniBlockPartialExecutionEnableEpoch represents the epoch when mini block partial execution will be enabled MiniBlockPartialExecutionEnableEpoch = 3 + # BLSMultiSignerEnableEpoch represents the activation epoch for different types of BLS multi-signers + BLSMultiSignerEnableEpoch = [ + { EnableEpoch = 0, Type = "no-KOSK"}, + { EnableEpoch = 3, Type = "KOSK"} + ] + # MaxNodesChangeEnableEpoch holds configuration for changing the maximum number of nodes and the enabling epoch MaxNodesChangeEnableEpoch = [ { EpochEnable = 0, MaxNumNodes = 36, NodesToShufflePerShard = 4 }, diff --git a/config/config.go b/config/config.go index db6d63c55d3..c13d8691261 100644 --- a/config/config.go +++ b/config/config.go @@ -270,6 +270,12 @@ type MaxNodesChangeConfig struct { NodesToShufflePerShard uint32 } +// MultiSignerConfig defines a config tuple for a BLS multi-signer that activates in a certain epoch +type MultiSignerConfig struct { + EnableEpoch uint32 + Type string +} + // GeneralSettingsConfig will hold the general settings for a node type GeneralSettingsConfig struct { StatusPollingIntervalSec int diff --git a/config/epochConfig.go b/config/epochConfig.go index 1df8e5b5931..d5d1495a630 100644 --- a/config/epochConfig.go +++ b/config/epochConfig.go @@ -85,6 +85,7 @@ type EnableEpochs struct { HeartbeatDisableEpoch uint32 MiniBlockPartialExecutionEnableEpoch uint32 ESDTMetadataContinuousCleanupEnableEpoch uint32 + BLSMultiSignerEnableEpoch []MultiSignerConfig } // GasScheduleByEpochs represents a gas schedule toml entry that will be applied from the provided epoch diff --git a/config/tomlConfig_test.go b/config/tomlConfig_test.go index 19e7654b3ac..d40eb8631ad 100644 --- a/config/tomlConfig_test.go +++ b/config/tomlConfig_test.go @@ -671,6 +671,11 @@ func TestEnableEpochConfig(t *testing.T) { { EpochEnable = 45, MaxNumNodes = 3200, NodesToShufflePerShard = 80 } ] + BLSMultiSignerEnableEpoch = [ + {EnableEpoch = 0, Type = "non-KOSK"}, + {EnableEpoch = 3, Type = "KOSK"} + ] + [GasSchedule] GasScheduleByEpochs = [ { StartEpoch = 46, FileName = "gasScheduleV1.toml" }, @@ -748,7 +753,18 @@ func TestEnableEpochConfig(t *testing.T) { ManagedCryptoAPIsEnableEpoch: 54, HeartbeatDisableEpoch: 55, ESDTMetadataContinuousCleanupEnableEpoch: 56, + BLSMultiSignerEnableEpoch: []MultiSignerConfig{ + { + EnableEpoch: 0, + Type: "non-KOSK", + }, + { + EnableEpoch: 3, + Type: "KOSK", + }, + }, }, + GasSchedule: GasScheduleConfig{ GasScheduleByEpochs: []GasScheduleByEpochs{ { diff --git a/consensus/mock/consensusDataContainerMock.go b/consensus/mock/consensusDataContainerMock.go index adbeaaf2c86..0382d83a694 100644 --- a/consensus/mock/consensusDataContainerMock.go +++ b/consensus/mock/consensusDataContainerMock.go @@ -85,7 +85,7 @@ func (ccm *ConsensusCoreMock) Marshalizer() marshal.Marshalizer { } // MultiSigner - -func (ccm *ConsensusCoreMock) MultiSigner() crypto.MultiSigner { +func (ccm *ConsensusCoreMock) MultiSignerContainer() process.MultiSignerContainer { return ccm.multiSigner } diff --git a/consensus/spos/bls/export_test.go b/consensus/spos/bls/export_test.go index bf48ba1aef7..ea97a936bee 100644 --- a/consensus/spos/bls/export_test.go +++ b/consensus/spos/bls/export_test.go @@ -62,7 +62,7 @@ func (fct *factory) Marshalizer() marshal.Marshalizer { // MultiSigner gets the multi signer object func (fct *factory) MultiSigner() crypto.MultiSigner { - return fct.consensusCore.MultiSigner() + return fct.consensusCore.MultiSignerContainer() } // RoundHandler gets the roundHandler object diff --git a/consensus/spos/bls/subroundEndRound.go b/consensus/spos/bls/subroundEndRound.go index dcec40eb6de..0826c4afef5 100644 --- a/consensus/spos/bls/subroundEndRound.go +++ b/consensus/spos/bls/subroundEndRound.go @@ -191,7 +191,7 @@ func (sr *subroundEndRound) doEndRoundJobByLeader() bool { } // Aggregate sig and add it to the block - sig, err := sr.MultiSigner().AggregateSigs(bitmap) + sig, err := sr.MultiSignerContainer().AggregateSigs(bitmap) if err != nil { log.Debug("doEndRoundJobByLeader.AggregateSigs", "error", err.Error()) return false diff --git a/consensus/spos/bls/subroundSignature.go b/consensus/spos/bls/subroundSignature.go index 5c0ff748f51..cd577be6623 100644 --- a/consensus/spos/bls/subroundSignature.go +++ b/consensus/spos/bls/subroundSignature.go @@ -69,7 +69,7 @@ func (sr *subroundSignature) doSignatureJob(_ context.Context) bool { return false } - signatureShare, err := sr.MultiSigner().CreateSignatureShare(sr.GetData(), nil) + signatureShare, err := sr.MultiSignerContainer().CreateSignatureShare(sr.GetData(), nil) if err != nil { log.Debug("doSignatureJob.CreateSignatureShare", "error", err.Error()) return false @@ -160,7 +160,7 @@ func (sr *subroundSignature) receivedSignature(_ context.Context, cnsDta *consen return false } - currentMultiSigner := sr.MultiSigner() + currentMultiSigner := sr.MultiSignerContainer() err = currentMultiSigner.VerifySignatureShare(uint16(index), cnsDta.SignatureShare, sr.GetData(), nil) if err != nil { log.Debug("receivedSignature.VerifySignatureShare", diff --git a/consensus/spos/bls/subroundStartRound.go b/consensus/spos/bls/subroundStartRound.go index a18fe9d893e..cae9649d3bf 100644 --- a/consensus/spos/bls/subroundStartRound.go +++ b/consensus/spos/bls/subroundStartRound.go @@ -181,7 +181,7 @@ func (sr *subroundStartRound) initCurrentRound() bool { sr.AppStatusHandler().SetStringValue(common.MetricConsensusState, "participant") } - err = sr.MultiSigner().Reset(pubKeys, uint16(selfIndex)) + err = sr.MultiSignerContainer().Reset(pubKeys, uint16(selfIndex)) if err != nil { log.Debug("initCurrentRound.Reset", "error", err.Error()) diff --git a/consensus/spos/consensusCore.go b/consensus/spos/consensusCore.go index a4cc7d313fb..752d7565810 100644 --- a/consensus/spos/consensusCore.go +++ b/consensus/spos/consensusCore.go @@ -25,7 +25,7 @@ type ConsensusCore struct { marshalizer marshal.Marshalizer blsPrivateKey crypto.PrivateKey blsSingleSigner crypto.SingleSigner - multiSigner crypto.MultiSigner + multiSignerContainer process.MultiSignerContainer roundHandler consensus.RoundHandler shardCoordinator sharding.Coordinator nodesCoordinator nodesCoordinator.NodesCoordinator @@ -50,7 +50,7 @@ type ConsensusCoreArgs struct { Marshalizer marshal.Marshalizer BlsPrivateKey crypto.PrivateKey BlsSingleSigner crypto.SingleSigner - MultiSigner crypto.MultiSigner + MultiSignerContainer process.MultiSignerContainer RoundHandler consensus.RoundHandler ShardCoordinator sharding.Coordinator NodesCoordinator nodesCoordinator.NodesCoordinator @@ -78,7 +78,7 @@ func NewConsensusCore( marshalizer: args.Marshalizer, blsPrivateKey: args.BlsPrivateKey, blsSingleSigner: args.BlsSingleSigner, - multiSigner: args.MultiSigner, + multiSignerContainer: args.MultiSignerContainer, roundHandler: args.RoundHandler, shardCoordinator: args.ShardCoordinator, nodesCoordinator: args.NodesCoordinator, @@ -141,8 +141,8 @@ func (cc *ConsensusCore) Marshalizer() marshal.Marshalizer { } // MultiSigner gets the MultiSigner stored in the ConsensusCore -func (cc *ConsensusCore) MultiSigner() crypto.MultiSigner { - return cc.multiSigner +func (cc *ConsensusCore) MultiSignerContainer() process.MultiSignerContainer { + return cc.multiSignerContainer } //RoundHandler gets the RoundHandler stored in the ConsensusCore diff --git a/consensus/spos/consensusCoreValidator.go b/consensus/spos/consensusCoreValidator.go index 67e5d35d385..d8360627493 100644 --- a/consensus/spos/consensusCoreValidator.go +++ b/consensus/spos/consensusCoreValidator.go @@ -28,7 +28,7 @@ func ValidateConsensusCore(container ConsensusCoreHandler) error { if check.IfNil(container.Marshalizer()) { return ErrNilMarshalizer } - if check.IfNil(container.MultiSigner()) { + if check.IfNil(container.MultiSignerContainer()) { return ErrNilMultiSigner } if check.IfNil(container.RoundHandler()) { diff --git a/consensus/spos/consensusCoreValidator_test.go b/consensus/spos/consensusCoreValidator_test.go index 1fa5cf60782..cc4c15e99f6 100644 --- a/consensus/spos/consensusCoreValidator_test.go +++ b/consensus/spos/consensusCoreValidator_test.go @@ -42,7 +42,7 @@ func initConsensusDataContainer() *ConsensusCore { marshalizer: marshalizerMock, blsPrivateKey: blsPrivateKeyMock, blsSingleSigner: blsSingleSignerMock, - multiSigner: multiSignerMock, + multiSignerContainer: multiSignerMock, roundHandler: roundHandlerMock, shardCoordinator: shardCoordinatorMock, syncTimer: syncTimerMock, @@ -125,7 +125,7 @@ func TestConsensusContainerValidator_ValidateNilMultiSignerShouldFail(t *testing t.Parallel() container := initConsensusDataContainer() - container.multiSigner = nil + container.multiSignerContainer = nil err := ValidateConsensusCore(container) diff --git a/consensus/spos/consensusCore_test.go b/consensus/spos/consensusCore_test.go index 3940da8e737..6e31c6d8cd6 100644 --- a/consensus/spos/consensusCore_test.go +++ b/consensus/spos/consensusCore_test.go @@ -24,7 +24,7 @@ func createDefaultConsensusCoreArgs() *spos.ConsensusCoreArgs { Marshalizer: consensusCoreMock.Marshalizer(), BlsPrivateKey: consensusCoreMock.PrivateKey(), BlsSingleSigner: consensusCoreMock.SingleSigner(), - MultiSigner: consensusCoreMock.MultiSigner(), + MultiSignerContainer: consensusCoreMock.MultiSignerContainer(), RoundHandler: consensusCoreMock.RoundHandler(), ShardCoordinator: consensusCoreMock.ShardCoordinator(), NodesCoordinator: consensusCoreMock.NodesCoordinator(), @@ -168,7 +168,7 @@ func TestConsensusCore_WithNilMultiSignerShouldFail(t *testing.T) { t.Parallel() args := createDefaultConsensusCoreArgs() - args.MultiSigner = nil + args.MultiSignerContainer = nil consensusCore, err := spos.NewConsensusCore( args, diff --git a/consensus/spos/interface.go b/consensus/spos/interface.go index 991fd8468bd..6906ac9d077 100644 --- a/consensus/spos/interface.go +++ b/consensus/spos/interface.go @@ -36,8 +36,8 @@ type ConsensusCoreHandler interface { Hasher() hashing.Hasher // Marshalizer gets the Marshalizer stored in the ConsensusCore Marshalizer() marshal.Marshalizer - // MultiSigner gets the MultiSigner stored in the ConsensusCore - MultiSigner() crypto.MultiSigner + // MultiSignerContainer gets the MultiSigner container from the ConsensusCore + MultiSignerContainer() process.MultiSignerContainer // RoundHandler gets the RoundHandler stored in the ConsensusCore RoundHandler() consensus.RoundHandler // ShardCoordinator gets the ShardCoordinator stored in the ConsensusCore diff --git a/epochStart/bootstrap/disabled/disabledMultiSignerContainer.go b/epochStart/bootstrap/disabled/disabledMultiSignerContainer.go new file mode 100644 index 00000000000..cb5a735fe13 --- /dev/null +++ b/epochStart/bootstrap/disabled/disabledMultiSignerContainer.go @@ -0,0 +1,24 @@ +package disabled + +import crypto "github.com/ElrondNetwork/elrond-go-crypto" + +type disabledMultiSignerContainer struct { + multiSigner crypto.MultiSigner +} + +// NewMultiSignerContainer creates a disabled multi signer container +func NewMultiSignerContainer() *disabledMultiSignerContainer { + return &disabledMultiSignerContainer{ + multiSigner: NewMultiSigner(), + } +} + +// GetMultiSigner returns a disabled multi signer as this is a disabled component +func (dmsc *disabledMultiSignerContainer) GetMultiSigner(_ uint32) (crypto.MultiSigner, error) { + return dmsc.multiSigner, nil +} + +// IsInterfaceNil returns true if the underlying object is nil +func (dmsc *disabledMultiSignerContainer) IsInterfaceNil() bool { + return dmsc == nil +} diff --git a/epochStart/bootstrap/factory/epochStartInterceptorsContainerFactory.go b/epochStart/bootstrap/factory/epochStartInterceptorsContainerFactory.go index da2a2f6a977..5ec8801a3bc 100644 --- a/epochStart/bootstrap/factory/epochStartInterceptorsContainerFactory.go +++ b/epochStart/bootstrap/factory/epochStartInterceptorsContainerFactory.go @@ -58,7 +58,7 @@ func NewEpochStartInterceptorsContainer(args ArgsEpochStartInterceptorContainer) } cryptoComponents := args.CryptoComponents.Clone().(process.CryptoComponentsHolder) - err := cryptoComponents.SetMultiSigner(disabled.NewMultiSigner()) + err := cryptoComponents.SetMultiSignerContainer(disabled.NewMultiSignerContainer()) if err != nil { return nil, err } diff --git a/errors/errors.go b/errors/errors.go index 0c2c4238eaf..6d131f073d3 100644 --- a/errors/errors.go +++ b/errors/errors.go @@ -478,3 +478,9 @@ var ErrNilTxsSender = errors.New("nil transactions sender has been provided") // ErrNilProcessStatusHandler signals that a nil process status handler was provided var ErrNilProcessStatusHandler = errors.New("nil process status handler") + +// ErrSignerNotSupported signals that a not supported signer was provided +var ErrSignerNotSupported = errors.New("signer not supported") + +// ErrMissingMultiSignerConfig signals that the multisigner config is missing +var ErrMissingMultiSignerConfig = errors.New("multisigner configuration missing") diff --git a/factory/consensus/consensusComponents.go b/factory/consensus/consensusComponents.go index bba4c1a221c..156c13505c9 100644 --- a/factory/consensus/consensusComponents.go +++ b/factory/consensus/consensusComponents.go @@ -230,7 +230,7 @@ func (ccf *consensusComponentsFactory) Create() (*consensusComponents, error) { Marshalizer: ccf.coreComponents.InternalMarshalizer(), BlsPrivateKey: ccf.cryptoComponents.PrivateKey(), BlsSingleSigner: ccf.cryptoComponents.BlockSigner(), - MultiSigner: ccf.cryptoComponents.MultiSigner(), + MultiSignerContainer: ccf.cryptoComponents.MultiSignerContainer(), RoundHandler: ccf.processComponents.RoundHandler(), ShardCoordinator: ccf.processComponents.ShardCoordinator(), NodesCoordinator: ccf.processComponents.NodesCoordinator(), diff --git a/factory/crypto/cryptoComponents.go b/factory/crypto/cryptoComponents.go index 58b9928ba2c..cbf6be11e4d 100644 --- a/factory/crypto/cryptoComponents.go +++ b/factory/crypto/cryptoComponents.go @@ -12,12 +12,10 @@ import ( "github.com/ElrondNetwork/elrond-go-crypto" "github.com/ElrondNetwork/elrond-go-crypto/signing" disabledCrypto "github.com/ElrondNetwork/elrond-go-crypto/signing/disabled" - disabledMultiSig "github.com/ElrondNetwork/elrond-go-crypto/signing/disabled/multisig" disabledSig "github.com/ElrondNetwork/elrond-go-crypto/signing/disabled/singlesig" "github.com/ElrondNetwork/elrond-go-crypto/signing/ed25519" "github.com/ElrondNetwork/elrond-go-crypto/signing/ed25519/singlesig" "github.com/ElrondNetwork/elrond-go-crypto/signing/mcl" - mclMultiSig "github.com/ElrondNetwork/elrond-go-crypto/signing/mcl/multisig" mclSig "github.com/ElrondNetwork/elrond-go-crypto/signing/mcl/singlesig" "github.com/ElrondNetwork/elrond-go-crypto/signing/multisig" logger "github.com/ElrondNetwork/elrond-go-logger" @@ -40,6 +38,7 @@ type CryptoComponentsFactoryArgs struct { ValidatorKeyPemFileName string SkIndex int Config config.Config + EnableEpochs config.EnableEpochs CoreComponentsHolder factory.CoreComponentsHolder ActivateBLSPubKeyMessageVerification bool KeyLoader factory.KeyLoaderHandler @@ -52,6 +51,7 @@ type cryptoComponentsFactory struct { validatorKeyPemFileName string skIndex int config config.Config + enableEpochs config.EnableEpochs coreComponentsHolder factory.CoreComponentsHolder activateBLSPubKeyMessageVerification bool keyLoader factory.KeyLoaderHandler @@ -70,13 +70,13 @@ type cryptoParams struct { // cryptoComponents struct holds the crypto components type cryptoComponents struct { - txSingleSigner crypto.SingleSigner - blockSingleSigner crypto.SingleSigner - multiSigner crypto.MultiSigner - peerSignHandler crypto.PeerSignatureHandler - blockSignKeyGen crypto.KeyGenerator - txSignKeyGen crypto.KeyGenerator - messageSignVerifier vm.MessageSignVerifier + txSingleSigner crypto.SingleSigner + blockSingleSigner crypto.SingleSigner + multiSignerContainer factory.MultiSignerContainer + peerSignHandler crypto.PeerSignatureHandler + blockSignKeyGen crypto.KeyGenerator + txSignKeyGen crypto.KeyGenerator + messageSignVerifier vm.MessageSignVerifier cryptoParams } @@ -104,6 +104,7 @@ func NewCryptoComponentsFactory(args CryptoComponentsFactoryArgs) (*cryptoCompon keyLoader: args.KeyLoader, isInImportMode: args.IsInImportMode, importModeNoSigCheck: args.ImportModeNoSigCheck, + enableEpochs: args.EnableEpochs, } return ccf, nil @@ -139,7 +140,7 @@ func (ccf *cryptoComponentsFactory) Create() (*cryptoComponents, error) { return nil, err } - multiSigner, err := ccf.createMultiSigner(multisigHasher, cp, blockSignKeyGen, ccf.importModeNoSigCheck) + multiSigner, err := ccf.createMultiSignerContainer(multisigHasher, cp, blockSignKeyGen, ccf.importModeNoSigCheck) if err != nil { return nil, err } @@ -171,14 +172,14 @@ func (ccf *cryptoComponentsFactory) Create() (*cryptoComponents, error) { log.Debug("block sign pubkey", "value", cp.publicKeyString) return &cryptoComponents{ - txSingleSigner: txSingleSigner, - blockSingleSigner: interceptSingleSigner, - multiSigner: multiSigner, - peerSignHandler: peerSigHandler, - blockSignKeyGen: blockSignKeyGen, - txSignKeyGen: txSignKeyGen, - messageSignVerifier: messageSignVerifier, - cryptoParams: *cp, + txSingleSigner: txSingleSigner, + blockSingleSigner: interceptSingleSigner, + multiSignerContainer: multiSigner, + peerSignHandler: peerSigHandler, + blockSignKeyGen: blockSignKeyGen, + txSignKeyGen: txSignKeyGen, + messageSignVerifier: messageSignVerifier, + cryptoParams: *cp, }, nil } @@ -217,27 +218,21 @@ func (ccf *cryptoComponentsFactory) getMultiSigHasherFromConfig() (hashing.Hashe return nil, errors.ErrMissingMultiHasherConfig } -func (ccf *cryptoComponentsFactory) createMultiSigner( +func (ccf *cryptoComponentsFactory) createMultiSignerContainer( hasher hashing.Hasher, cp *cryptoParams, blSignKeyGen crypto.KeyGenerator, importModeNoSigCheck bool, -) (crypto.MultiSigner, error) { - if importModeNoSigCheck { - log.Warn("using disabled multi signer because the node is running in import-db 'turbo mode'") - return &disabledMultiSig.DisabledMultiSig{}, nil - } - - switch ccf.consensusType { - case consensus.BlsConsensusType: - blsSigner := &mclMultiSig.BlsMultiSigner{Hasher: hasher} - return multisig.NewBLSMultisig(blsSigner, []string{string(cp.publicKeyBytes)}, cp.privateKey, blSignKeyGen, uint16(0)) - case disabledSigChecking: - log.Warn("using disabled multi signer") - return &disabledMultiSig.DisabledMultiSig{}, nil - default: - return nil, errors.ErrInvalidConsensusConfig +) (factory.MultiSignerContainer, error) { + + args := MultiSigArgs{ + hasher: hasher, + cryptoParams: cp, + blSignKeyGen: blSignKeyGen, + consensusType: ccf.consensusType, + importModeNoSigCheck: importModeNoSigCheck, } + return NewMultiSignerContainer(args, ccf.enableEpochs.BLSMultiSignerEnableEpoch) } func (ccf *cryptoComponentsFactory) getSuite() (crypto.Suite, error) { diff --git a/factory/crypto/cryptoComponentsHandler.go b/factory/crypto/cryptoComponentsHandler.go index b1295348150..a8f30109ab7 100644 --- a/factory/crypto/cryptoComponentsHandler.go +++ b/factory/crypto/cryptoComponentsHandler.go @@ -90,7 +90,7 @@ func (mcc *managedCryptoComponents) CheckSubcomponents() error { if check.IfNil(mcc.cryptoComponents.blockSingleSigner) { return errors.ErrNilBlockSigner } - if check.IfNil(mcc.cryptoComponents.multiSigner) { + if check.IfNil(mcc.cryptoComponents.multiSignerContainer) { return errors.ErrNilMultiSigner } if check.IfNil(mcc.cryptoComponents.peerSignHandler) { @@ -193,8 +193,8 @@ func (mcc *managedCryptoComponents) BlockSigner() crypto.SingleSigner { return mcc.cryptoComponents.blockSingleSigner } -// MultiSigner returns the block multi-signer -func (mcc *managedCryptoComponents) MultiSigner() crypto.MultiSigner { +// MultiSignerContainer returns the block multi-signer container +func (mcc *managedCryptoComponents) MultiSignerContainer() factory.MultiSignerContainer { mcc.mutCryptoComponents.RLock() defer mcc.mutCryptoComponents.RUnlock() @@ -202,7 +202,19 @@ func (mcc *managedCryptoComponents) MultiSigner() crypto.MultiSigner { return nil } - return mcc.cryptoComponents.multiSigner + return mcc.cryptoComponents.multiSignerContainer +} + +// GetMultiSigner returns the block multi signer valid for the given epoch +func (mcc *managedCryptoComponents) GetMultiSigner(epoch uint32) (crypto.MultiSigner, error) { + mcc.mutCryptoComponents.RLock() + defer mcc.mutCryptoComponents.RUnlock() + + if mcc.cryptoComponents == nil { + return nil, errors.ErrNilCryptoComponents + } + + return mcc.cryptoComponents.multiSignerContainer.GetMultiSigner(epoch) } // PeerSignatureHandler returns the peer signature handler @@ -217,8 +229,8 @@ func (mcc *managedCryptoComponents) PeerSignatureHandler() crypto.PeerSignatureH return mcc.cryptoComponents.peerSignHandler } -// SetMultiSigner sets the block multi-signer -func (mcc *managedCryptoComponents) SetMultiSigner(ms crypto.MultiSigner) error { +// SetMultiSignerContainer sets the block multi-signer container +func (mcc *managedCryptoComponents) SetMultiSignerContainer(ms factory.MultiSignerContainer) error { mcc.mutCryptoComponents.Lock() defer mcc.mutCryptoComponents.Unlock() @@ -226,7 +238,7 @@ func (mcc *managedCryptoComponents) SetMultiSigner(ms crypto.MultiSigner) error return errors.ErrNilCryptoComponents } - mcc.cryptoComponents.multiSigner = ms + mcc.cryptoComponents.multiSignerContainer = ms return nil } @@ -271,14 +283,14 @@ func (mcc *managedCryptoComponents) Clone() interface{} { cryptoComp := (*cryptoComponents)(nil) if mcc.cryptoComponents != nil { cryptoComp = &cryptoComponents{ - txSingleSigner: mcc.TxSingleSigner(), - blockSingleSigner: mcc.BlockSigner(), - multiSigner: mcc.MultiSigner(), - peerSignHandler: mcc.PeerSignatureHandler(), - blockSignKeyGen: mcc.BlockSignKeyGen(), - txSignKeyGen: mcc.TxSignKeyGen(), - messageSignVerifier: mcc.MessageSignVerifier(), - cryptoParams: mcc.cryptoParams, + txSingleSigner: mcc.TxSingleSigner(), + blockSingleSigner: mcc.BlockSigner(), + multiSignerContainer: mcc.MultiSignerContainer(), + peerSignHandler: mcc.PeerSignatureHandler(), + blockSignKeyGen: mcc.BlockSignKeyGen(), + txSignKeyGen: mcc.TxSignKeyGen(), + messageSignVerifier: mcc.MessageSignVerifier(), + cryptoParams: mcc.cryptoParams, } } diff --git a/factory/crypto/cryptoComponentsHandler_test.go b/factory/crypto/cryptoComponentsHandler_test.go index 1498c0cd049..d9daf557f46 100644 --- a/factory/crypto/cryptoComponentsHandler_test.go +++ b/factory/crypto/cryptoComponentsHandler_test.go @@ -3,10 +3,10 @@ package crypto_test import ( "testing" + "github.com/ElrondNetwork/elrond-go/errors" "github.com/ElrondNetwork/elrond-go/factory" cryptoComp "github.com/ElrondNetwork/elrond-go/factory/crypto" componentsMock "github.com/ElrondNetwork/elrond-go/factory/mock/components" - "github.com/ElrondNetwork/elrond-go/testscommon/cryptoMocks" "github.com/stretchr/testify/require" ) @@ -41,7 +41,7 @@ func TestManagedCryptoComponents_CreateShouldWork(t *testing.T) { require.NoError(t, err) require.Nil(t, managedCryptoComponents.TxSingleSigner()) require.Nil(t, managedCryptoComponents.BlockSigner()) - require.Nil(t, managedCryptoComponents.MultiSigner()) + require.Nil(t, managedCryptoComponents.MultiSignerContainer()) require.Nil(t, managedCryptoComponents.BlockSignKeyGen()) require.Nil(t, managedCryptoComponents.TxSignKeyGen()) require.Nil(t, managedCryptoComponents.MessageSignVerifier()) @@ -50,7 +50,10 @@ func TestManagedCryptoComponents_CreateShouldWork(t *testing.T) { require.NoError(t, err) require.NotNil(t, managedCryptoComponents.TxSingleSigner()) require.NotNil(t, managedCryptoComponents.BlockSigner()) - require.NotNil(t, managedCryptoComponents.MultiSigner()) + require.NotNil(t, managedCryptoComponents.MultiSignerContainer()) + multiSigner, errGet := managedCryptoComponents.MultiSignerContainer().GetMultiSigner(0) + require.NotNil(t, multiSigner) + require.Nil(t, errGet) require.NotNil(t, managedCryptoComponents.BlockSignKeyGen()) require.NotNil(t, managedCryptoComponents.TxSignKeyGen()) require.NotNil(t, managedCryptoComponents.MessageSignVerifier()) @@ -68,20 +71,20 @@ func TestManagedCryptoComponents_CheckSubcomponents(t *testing.T) { require.NoError(t, err) } -func TestManagedCryptoComponents_SetMultiSigner(t *testing.T) { - t.Parallel() - if testing.Short() { - t.Skip("this is not a short test") - } - - managedCryptoComponents := getManagedCryptoComponents(t) - - ms := &cryptoMocks.MultisignerMock{} - err := managedCryptoComponents.SetMultiSigner(ms) - require.NoError(t, err) - - require.Equal(t, managedCryptoComponents.MultiSigner(), ms) -} +//func TestManagedCryptoComponents_SetMultiSigner(t *testing.T) { +// t.Parallel() +// if testing.Short() { +// t.Skip("this is not a short test") +// } +// +// managedCryptoComponents := getManagedCryptoComponents(t) +// +// ms := &cryptoMocks.MultisignerMock{} +// err := managedCryptoComponents.SetMultiSigner(ms) +// require.NoError(t, err) +// +// require.Equal(t, managedCryptoComponents.MultiSignerContainer(), ms) +//} func TestManagedCryptoComponents_Close(t *testing.T) { t.Parallel() @@ -93,7 +96,9 @@ func TestManagedCryptoComponents_Close(t *testing.T) { err := managedCryptoComponents.Close() require.NoError(t, err) - require.Nil(t, managedCryptoComponents.MultiSigner()) + multiSigner, errGet := managedCryptoComponents.GetMultiSigner(0) + require.Nil(t, multiSigner) + require.Equal(t, errors.ErrNilMultiSigner, errGet) } func getManagedCryptoComponents(t *testing.T) factory.CryptoComponentsHandler { diff --git a/factory/crypto/cryptoComponents_test.go b/factory/crypto/cryptoComponents_test.go index 678d156e5f0..bde7cf0f0f4 100644 --- a/factory/crypto/cryptoComponents_test.go +++ b/factory/crypto/cryptoComponents_test.go @@ -276,7 +276,7 @@ func TestCryptoComponentsFactory_CreateMultiSignerInvalidConsensusTypeShouldErr( require.Nil(t, err) cp := ccf.CreateDummyCryptoParams() - multiSigner, err := ccf.CreateMultiSigner(&hashingMocks.HasherMock{}, cp, &mock.KeyGenMock{}, false) + multiSigner, err := ccf.CreateMultiSignerContainer(&hashingMocks.HasherMock{}, cp, &mock.KeyGenMock{}, false) require.Nil(t, multiSigner) require.Equal(t, errErd.ErrInvalidConsensusConfig, err) } @@ -298,7 +298,7 @@ func TestCryptoComponentsFactory_CreateMultiSignerOK(t *testing.T) { cp, _ := ccf.CreateCryptoParams(blockSignKeyGen) multisigHasher, _ := ccf.GetMultiSigHasherFromConfig() - multiSigner, err := ccf.CreateMultiSigner(multisigHasher, cp, blockSignKeyGen, false) + multiSigner, err := ccf.CreateMultiSignerContainer(multisigHasher, cp, blockSignKeyGen, false) require.Nil(t, err) require.NotNil(t, multiSigner) } diff --git a/factory/crypto/export_test.go b/factory/crypto/export_test.go index 23c178c98a2..73df2f5836c 100644 --- a/factory/crypto/export_test.go +++ b/factory/crypto/export_test.go @@ -3,6 +3,7 @@ package crypto import ( "github.com/ElrondNetwork/elrond-go-core/hashing" crypto "github.com/ElrondNetwork/elrond-go-crypto" + "github.com/ElrondNetwork/elrond-go/factory" ) // GetSkPk - @@ -30,11 +31,11 @@ func (ccf *cryptoComponentsFactory) CreateCryptoParams(blockSignKeyGen crypto.Ke return ccf.createCryptoParams(blockSignKeyGen) } -// CreateMultiSigner - -func (ccf *cryptoComponentsFactory) CreateMultiSigner( +// CreateMultiSignerContainer - +func (ccf *cryptoComponentsFactory) CreateMultiSignerContainer( h hashing.Hasher, cp *cryptoParams, blSignKeyGen crypto.KeyGenerator, importModeNoSigCheck bool, -) (crypto.MultiSigner, error) { - return ccf.createMultiSigner(h, cp, blSignKeyGen, importModeNoSigCheck) +) (factory.MultiSignerContainer, error) { + return ccf.createMultiSignerContainer(h, cp, blSignKeyGen, importModeNoSigCheck) } // GetSuite - diff --git a/factory/crypto/multiSignerContainer.go b/factory/crypto/multiSignerContainer.go new file mode 100644 index 00000000000..afcd42b5f50 --- /dev/null +++ b/factory/crypto/multiSignerContainer.go @@ -0,0 +1,133 @@ +package crypto + +import ( + "sort" + "sync" + + "github.com/ElrondNetwork/elrond-go-core/core/check" + "github.com/ElrondNetwork/elrond-go-core/hashing" + crypto "github.com/ElrondNetwork/elrond-go-crypto" + disabledMultiSig "github.com/ElrondNetwork/elrond-go-crypto/signing/disabled/multisig" + mclMultiSig "github.com/ElrondNetwork/elrond-go-crypto/signing/mcl/multisig" + "github.com/ElrondNetwork/elrond-go-crypto/signing/multisig" + "github.com/ElrondNetwork/elrond-go/config" + "github.com/ElrondNetwork/elrond-go/consensus" + "github.com/ElrondNetwork/elrond-go/errors" +) + +const ( + blsNonKOSK = "non-KOSK" + blsKOSK = "KOSK" +) + +type epochMultiSigner struct { + epoch uint32 + multiSigner crypto.MultiSigner +} + +type container struct { + multiSigners []*epochMultiSigner + mutSigners sync.RWMutex +} + +// MultiSigArgs holds the arguments for creating the multiSignerContainer container +type MultiSigArgs struct { + hasher hashing.Hasher + cryptoParams *cryptoParams + blSignKeyGen crypto.KeyGenerator + consensusType string + importModeNoSigCheck bool +} + +// NewMultiSignerContainer creates the multiSignerContainer container +func NewMultiSignerContainer(args MultiSigArgs, multiSignerConfig []config.MultiSignerConfig) (*container, error) { + if len(multiSignerConfig) == 0 { + return nil, errors.ErrMissingMultiSignerConfig + } + + c := &container{ + multiSigners: make([]*epochMultiSigner, len(multiSignerConfig)), + } + + sortedMultiSignerConfig := sortMultiSignerConfig(multiSignerConfig) + if sortedMultiSignerConfig[0].EnableEpoch != 0 { + return nil, errors.ErrNilMultiSigner + } + + for i, mConfig := range sortedMultiSignerConfig { + multiSigner, err := createMultiSigner(mConfig.Type, args) + if err != nil { + return nil, err + } + + c.multiSigners[i] = &epochMultiSigner{ + multiSigner: multiSigner, + epoch: mConfig.EnableEpoch, + } + } + + return c, nil +} + +// GetMultiSigner returns the multiSignerContainer configured for the given epoch +func (c *container) GetMultiSigner(epoch uint32) (crypto.MultiSigner, error) { + c.mutSigners.RLock() + defer c.mutSigners.RUnlock() + + for i := len(c.multiSigners) - 1; i >= 0; i-- { + if epoch >= c.multiSigners[i].epoch { + return c.multiSigners[i].multiSigner, nil + } + } + return nil, errors.ErrMissingMultiSignerConfig +} + +// IsInterfaceNil returns true if the underlying object is nil +func (c *container) IsInterfaceNil() bool { + return c == nil +} + +func createMultiSigner(multiSigType string, args MultiSigArgs) (crypto.MultiSigner, error) { + if args.importModeNoSigCheck { + log.Warn("using disabled multi signer because the node is running in import-db 'turbo mode'") + return &disabledMultiSig.DisabledMultiSig{}, nil + } + + switch args.consensusType { + case consensus.BlsConsensusType: + blsSigner, err := createLowLevelSigner(multiSigType, args.hasher) + if err != nil { + return nil, err + } + return multisig.NewBLSMultisig(blsSigner, []string{string(args.cryptoParams.publicKeyBytes)}, args.cryptoParams.privateKey, args.blSignKeyGen, uint16(0)) + case disabledSigChecking: + log.Warn("using disabled multi signer") + return &disabledMultiSig.DisabledMultiSig{}, nil + default: + return nil, errors.ErrInvalidConsensusConfig + } +} + +func createLowLevelSigner(multiSigType string, hasher hashing.Hasher) (crypto.LowLevelSignerBLS, error) { + if check.IfNil(hasher) { + return nil, errors.ErrNilHasher + } + + switch multiSigType { + case blsNonKOSK: + return &mclMultiSig.BlsMultiSigner{Hasher: hasher}, nil + case blsKOSK: + return &mclMultiSig.BlsMultiSignerKOSK{}, nil + default: + return nil, errors.ErrSignerNotSupported + } +} + +func sortMultiSignerConfig(multiSignerConfig []config.MultiSignerConfig) []config.MultiSignerConfig { + sortedMultiSignerConfig := append([]config.MultiSignerConfig{}, multiSignerConfig...) + sort.Slice(sortedMultiSignerConfig, func(i, j int) bool { + return sortedMultiSignerConfig[i].EnableEpoch < sortedMultiSignerConfig[j].EnableEpoch + }) + + return sortedMultiSignerConfig +} diff --git a/factory/interface.go b/factory/interface.go index 6589d70076b..adbf49cee49 100644 --- a/factory/interface.go +++ b/factory/interface.go @@ -150,14 +150,21 @@ type CryptoParamsHolder interface { PrivateKeyBytes() []byte } +// MultiSignerContainer defines the container for different versioned multiSigner instances +type MultiSignerContainer interface { + GetMultiSigner(epoch uint32) (crypto.MultiSigner, error) + IsInterfaceNil() bool +} + // CryptoComponentsHolder holds the crypto components type CryptoComponentsHolder interface { CryptoParamsHolder TxSingleSigner() crypto.SingleSigner BlockSigner() crypto.SingleSigner - MultiSigner() crypto.MultiSigner + SetMultiSignerContainer(container MultiSignerContainer) error + MultiSignerContainer() MultiSignerContainer + GetMultiSigner(epoch uint32) (crypto.MultiSigner, error) PeerSignatureHandler() crypto.PeerSignatureHandler - SetMultiSigner(ms crypto.MultiSigner) error BlockSignKeyGen() crypto.KeyGenerator TxSignKeyGen() crypto.KeyGenerator MessageSignVerifier() vm.MessageSignVerifier diff --git a/factory/mock/components/default.go b/factory/mock/components/default.go index 6aeea857dcc..b5b8bd1bd9e 100644 --- a/factory/mock/components/default.go +++ b/factory/mock/components/default.go @@ -53,18 +53,18 @@ func GetDefaultCoreComponents() *mock.CoreComponentsMock { // GetDefaultCryptoComponents - func GetDefaultCryptoComponents() *mock.CryptoComponentsMock { return &mock.CryptoComponentsMock{ - PubKey: &mock.PublicKeyMock{}, - PrivKey: &mock.PrivateKeyStub{}, - PubKeyString: "pubKey", - PrivKeyBytes: []byte("privKey"), - PubKeyBytes: []byte("pubKey"), - BlockSig: &mock.SinglesignMock{}, - TxSig: &mock.SinglesignMock{}, - MultiSig: &cryptoMocks.MultisignerStub{}, - PeerSignHandler: &mock.PeerSignatureHandler{}, - BlKeyGen: &mock.KeyGenMock{}, - TxKeyGen: &mock.KeyGenMock{}, - MsgSigVerifier: &testscommon.MessageSignVerifierMock{}, + PubKey: &mock.PublicKeyMock{}, + PrivKey: &mock.PrivateKeyStub{}, + PubKeyString: "pubKey", + PrivKeyBytes: []byte("privKey"), + PubKeyBytes: []byte("pubKey"), + BlockSig: &mock.SinglesignMock{}, + TxSig: &mock.SinglesignMock{}, + MultiSigContainer: &cryptoMocks.MultisignerStub{}, + PeerSignHandler: &mock.PeerSignatureHandler{}, + BlKeyGen: &mock.KeyGenMock{}, + TxKeyGen: &mock.KeyGenMock{}, + MsgSigVerifier: &testscommon.MessageSignVerifierMock{}, } } diff --git a/factory/mock/cryptoComponentsMock.go b/factory/mock/cryptoComponentsMock.go index 8ece29b3749..51ecd42b7d6 100644 --- a/factory/mock/cryptoComponentsMock.go +++ b/factory/mock/cryptoComponentsMock.go @@ -1,27 +1,29 @@ package mock import ( + "errors" "sync" "github.com/ElrondNetwork/elrond-go-crypto" + "github.com/ElrondNetwork/elrond-go/factory" "github.com/ElrondNetwork/elrond-go/vm" ) // CryptoComponentsMock - type CryptoComponentsMock struct { - PubKey crypto.PublicKey - PrivKey crypto.PrivateKey - PubKeyString string - PrivKeyBytes []byte - PubKeyBytes []byte - BlockSig crypto.SingleSigner - TxSig crypto.SingleSigner - MultiSig crypto.MultiSigner - PeerSignHandler crypto.PeerSignatureHandler - BlKeyGen crypto.KeyGenerator - TxKeyGen crypto.KeyGenerator - MsgSigVerifier vm.MessageSignVerifier - mutMultiSig sync.RWMutex + PubKey crypto.PublicKey + PrivKey crypto.PrivateKey + PubKeyString string + PrivKeyBytes []byte + PubKeyBytes []byte + BlockSig crypto.SingleSigner + TxSig crypto.SingleSigner + MultiSigContainer factory.MultiSignerContainer + PeerSignHandler crypto.PeerSignatureHandler + BlKeyGen crypto.KeyGenerator + TxKeyGen crypto.KeyGenerator + MsgSigVerifier vm.MessageSignVerifier + mutMultiSig sync.RWMutex } // PublicKey - @@ -59,12 +61,12 @@ func (ccm *CryptoComponentsMock) TxSingleSigner() crypto.SingleSigner { return ccm.TxSig } -// MultiSigner - -func (ccm *CryptoComponentsMock) MultiSigner() crypto.MultiSigner { +// MultiSignerContainer - +func (ccm *CryptoComponentsMock) MultiSignerContainer() factory.MultiSignerContainer { ccm.mutMultiSig.RLock() defer ccm.mutMultiSig.RUnlock() - return ccm.MultiSig + return ccm.MultiSigContainer } // PeerSignatureHandler - @@ -75,10 +77,22 @@ func (ccm *CryptoComponentsMock) PeerSignatureHandler() crypto.PeerSignatureHand return ccm.PeerSignHandler } -// SetMultiSigner - -func (ccm *CryptoComponentsMock) SetMultiSigner(ms crypto.MultiSigner) error { +// GetMultiSigner - +func (ccm *CryptoComponentsMock) GetMultiSigner(epoch uint32) (crypto.MultiSigner, error) { + ccm.mutMultiSig.RLock() + defer ccm.mutMultiSig.RUnlock() + + if ccm.MultiSigContainer == nil { + return nil, errors.New("nil multi sig container") + } + + return ccm.MultiSigContainer.GetMultiSigner(epoch) +} + +// SetMultiSignerContainer - +func (ccm *CryptoComponentsMock) SetMultiSignerContainer(ms factory.MultiSignerContainer) error { ccm.mutMultiSig.Lock() - ccm.MultiSig = ms + ccm.MultiSigContainer = ms ccm.mutMultiSig.Unlock() return nil @@ -102,19 +116,19 @@ func (ccm *CryptoComponentsMock) MessageSignVerifier() vm.MessageSignVerifier { // Clone - func (ccm *CryptoComponentsMock) Clone() interface{} { return &CryptoComponentsMock{ - PubKey: ccm.PubKey, - PrivKey: ccm.PrivKey, - PubKeyString: ccm.PubKeyString, - PrivKeyBytes: ccm.PrivKeyBytes, - PubKeyBytes: ccm.PubKeyBytes, - BlockSig: ccm.BlockSig, - TxSig: ccm.TxSig, - MultiSig: ccm.MultiSig, - PeerSignHandler: ccm.PeerSignHandler, - BlKeyGen: ccm.BlKeyGen, - TxKeyGen: ccm.TxKeyGen, - MsgSigVerifier: ccm.MsgSigVerifier, - mutMultiSig: sync.RWMutex{}, + PubKey: ccm.PubKey, + PrivKey: ccm.PrivKey, + PubKeyString: ccm.PubKeyString, + PrivKeyBytes: ccm.PrivKeyBytes, + PubKeyBytes: ccm.PubKeyBytes, + BlockSig: ccm.BlockSig, + TxSig: ccm.TxSig, + MultiSigContainer: ccm.MultiSigContainer, + PeerSignHandler: ccm.PeerSignHandler, + BlKeyGen: ccm.BlKeyGen, + TxKeyGen: ccm.TxKeyGen, + MsgSigVerifier: ccm.MsgSigVerifier, + mutMultiSig: sync.RWMutex{}, } } diff --git a/factory/processing/processComponents.go b/factory/processing/processComponents.go index 28d2956f7ad..7cfa11b3346 100644 --- a/factory/processing/processComponents.go +++ b/factory/processing/processComponents.go @@ -239,7 +239,7 @@ func (pcf *processComponentsFactory) Create() (*processComponents, error) { Marshalizer: pcf.coreData.InternalMarshalizer(), Hasher: pcf.coreData.Hasher(), NodesCoordinator: pcf.nodesCoordinator, - MultiSigVerifier: pcf.crypto.MultiSigner(), + MultiSigContainer: pcf.crypto.MultiSignerContainer(), SingleSigVerifier: pcf.crypto.BlockSigner(), KeyGen: pcf.crypto.BlockSignKeyGen(), FallbackHeaderValidator: fallbackHeaderValidator, diff --git a/go.mod b/go.mod index bbbd8650f88..096a428db08 100644 --- a/go.mod +++ b/go.mod @@ -10,7 +10,7 @@ require ( github.com/ElrondNetwork/covalent-indexer-go v1.0.6 github.com/ElrondNetwork/elastic-indexer-go v1.2.34-partial-execution github.com/ElrondNetwork/elrond-go-core v1.1.16-0.20220708085217-ccc0c5ac9076 - github.com/ElrondNetwork/elrond-go-crypto v1.0.1 + github.com/ElrondNetwork/elrond-go-crypto v1.1.0 github.com/ElrondNetwork/elrond-go-logger v1.0.7 github.com/ElrondNetwork/elrond-vm-common v1.3.13 github.com/ElrondNetwork/go-libp2p-pubsub v0.6.1-rc1 diff --git a/go.sum b/go.sum index 53a80afa690..50cf78dedb2 100644 --- a/go.sum +++ b/go.sum @@ -64,8 +64,8 @@ github.com/ElrondNetwork/elrond-go-core v1.1.16-0.20220414130405-e3cc29bc7711/go github.com/ElrondNetwork/elrond-go-core v1.1.16-0.20220708085217-ccc0c5ac9076 h1:/tNU9ydW91/rZAFTDXSDhLSPEcBs9w6+g+4NF6uqMeo= github.com/ElrondNetwork/elrond-go-core v1.1.16-0.20220708085217-ccc0c5ac9076/go.mod h1:Yz8JK5sGBctw7+gU8j2mZHbzQ09Ek4XHJ4Uinq1N6nM= github.com/ElrondNetwork/elrond-go-crypto v1.0.0/go.mod h1:DGiR7/j1xv729Xg8SsjYaUzWXL5svMd44REXjWS/gAc= -github.com/ElrondNetwork/elrond-go-crypto v1.0.1 h1:xJUUshIZQ7h+rG7Art/9QHVyaPRV1wEjrxXYBdpmRlM= -github.com/ElrondNetwork/elrond-go-crypto v1.0.1/go.mod h1:uunsvweBrrhVojL8uiQSaTPsl3YIQ9iBqtYGM6xs4s0= +github.com/ElrondNetwork/elrond-go-crypto v1.1.0 h1:fC4FPl7u45llTf+fkQjsSA30QKVww3be4TZsiKMH94A= +github.com/ElrondNetwork/elrond-go-crypto v1.1.0/go.mod h1:uunsvweBrrhVojL8uiQSaTPsl3YIQ9iBqtYGM6xs4s0= github.com/ElrondNetwork/elrond-go-logger v1.0.4/go.mod h1:e5D+c97lKUfFdAzFX7rrI2Igl/z4Y0RkKYKWyzprTGk= github.com/ElrondNetwork/elrond-go-logger v1.0.5/go.mod h1:cBfgx0ST/CJx8jrxJSC5aiSrvkGzcnF7sK06RD8mFxQ= github.com/ElrondNetwork/elrond-go-logger v1.0.7 h1:Ldl1rVS0RGKc1IsW8jIaGCb6Zwei04gsMvyjL05X6mE= diff --git a/integrationTests/consensus/testInitializer.go b/integrationTests/consensus/testInitializer.go index 24794094647..c9cc3213d11 100644 --- a/integrationTests/consensus/testInitializer.go +++ b/integrationTests/consensus/testInitializer.go @@ -414,7 +414,7 @@ func createConsensusOnlyNode( cryptoComponents.PubKey = privKey.GeneratePublic() cryptoComponents.BlockSig = singleBlsSigner cryptoComponents.TxSig = singlesigner - cryptoComponents.MultiSig = testMultiSig + cryptoComponents.MultiSigContainer = testMultiSig cryptoComponents.BlKeyGen = testKeyGen cryptoComponents.PeerSignHandler = peerSigHandler diff --git a/integrationTests/mock/cryptoComponentsStub.go b/integrationTests/mock/cryptoComponentsStub.go index 5979f703b9e..6e93e49805f 100644 --- a/integrationTests/mock/cryptoComponentsStub.go +++ b/integrationTests/mock/cryptoComponentsStub.go @@ -1,27 +1,29 @@ package mock import ( + "errors" "sync" "github.com/ElrondNetwork/elrond-go-crypto" + "github.com/ElrondNetwork/elrond-go/factory" "github.com/ElrondNetwork/elrond-go/vm" ) // CryptoComponentsStub - type CryptoComponentsStub struct { - PubKey crypto.PublicKey - PrivKey crypto.PrivateKey - PubKeyString string - PrivKeyBytes []byte - PubKeyBytes []byte - BlockSig crypto.SingleSigner - TxSig crypto.SingleSigner - MultiSig crypto.MultiSigner - PeerSignHandler crypto.PeerSignatureHandler - BlKeyGen crypto.KeyGenerator - TxKeyGen crypto.KeyGenerator - MsgSigVerifier vm.MessageSignVerifier - mutMultiSig sync.RWMutex + PubKey crypto.PublicKey + PrivKey crypto.PrivateKey + PubKeyString string + PrivKeyBytes []byte + PubKeyBytes []byte + BlockSig crypto.SingleSigner + TxSig crypto.SingleSigner + MultiSigContainer factory.MultiSignerContainer + PeerSignHandler crypto.PeerSignatureHandler + BlKeyGen crypto.KeyGenerator + TxKeyGen crypto.KeyGenerator + MsgSigVerifier vm.MessageSignVerifier + mutMultiSig sync.RWMutex } // Create - @@ -74,12 +76,12 @@ func (ccs *CryptoComponentsStub) TxSingleSigner() crypto.SingleSigner { return ccs.TxSig } -// MultiSigner - -func (ccs *CryptoComponentsStub) MultiSigner() crypto.MultiSigner { +// MultiSignerContainer - +func (ccs *CryptoComponentsStub) MultiSignerContainer() factory.MultiSignerContainer { ccs.mutMultiSig.RLock() defer ccs.mutMultiSig.RUnlock() - return ccs.MultiSig + return ccs.MultiSigContainer } // PeerSignatureHandler - @@ -90,15 +92,27 @@ func (ccs *CryptoComponentsStub) PeerSignatureHandler() crypto.PeerSignatureHand return ccs.PeerSignHandler } -// SetMultiSigner - -func (ccs *CryptoComponentsStub) SetMultiSigner(ms crypto.MultiSigner) error { +// SetMultiSignerContainer - +func (ccs *CryptoComponentsStub) SetMultiSignerContainer(ms factory.MultiSignerContainer) error { ccs.mutMultiSig.Lock() - ccs.MultiSig = ms + ccs.MultiSigContainer = ms ccs.mutMultiSig.Unlock() return nil } +// GetMultiSigner - +func (ccs *CryptoComponentsStub) GetMultiSigner(epoch uint32) (crypto.MultiSigner, error) { + ccs.mutMultiSig.RLock() + defer ccs.mutMultiSig.RUnlock() + + if ccs.MultiSigContainer == nil { + return nil, errors.New("nil multi sig container") + } + + return ccs.MultiSigContainer.GetMultiSigner(epoch) +} + // BlockSignKeyGen - func (ccs *CryptoComponentsStub) BlockSignKeyGen() crypto.KeyGenerator { return ccs.BlKeyGen @@ -117,19 +131,19 @@ func (ccs *CryptoComponentsStub) MessageSignVerifier() vm.MessageSignVerifier { // Clone - func (ccs *CryptoComponentsStub) Clone() interface{} { return &CryptoComponentsStub{ - PubKey: ccs.PubKey, - PrivKey: ccs.PrivKey, - PubKeyString: ccs.PubKeyString, - PrivKeyBytes: ccs.PrivKeyBytes, - PubKeyBytes: ccs.PubKeyBytes, - BlockSig: ccs.BlockSig, - TxSig: ccs.TxSig, - MultiSig: ccs.MultiSig, - PeerSignHandler: ccs.PeerSignHandler, - BlKeyGen: ccs.BlKeyGen, - TxKeyGen: ccs.TxKeyGen, - MsgSigVerifier: ccs.MsgSigVerifier, - mutMultiSig: sync.RWMutex{}, + PubKey: ccs.PubKey, + PrivKey: ccs.PrivKey, + PubKeyString: ccs.PubKeyString, + PrivKeyBytes: ccs.PrivKeyBytes, + PubKeyBytes: ccs.PubKeyBytes, + BlockSig: ccs.BlockSig, + TxSig: ccs.TxSig, + MultiSigContainer: ccs.MultiSigContainer, + PeerSignHandler: ccs.PeerSignHandler, + BlKeyGen: ccs.BlKeyGen, + TxKeyGen: ccs.TxKeyGen, + MsgSigVerifier: ccs.MsgSigVerifier, + mutMultiSig: sync.RWMutex{}, } } diff --git a/integrationTests/multiShard/hardFork/hardFork_test.go b/integrationTests/multiShard/hardFork/hardFork_test.go index 315a4d32c1b..d0792de4a1b 100644 --- a/integrationTests/multiShard/hardFork/hardFork_test.go +++ b/integrationTests/multiShard/hardFork/hardFork_test.go @@ -564,7 +564,7 @@ func createHardForkExporter( cryptoComponents := integrationTests.GetDefaultCryptoComponents() cryptoComponents.BlockSig = node.OwnAccount.BlockSingleSigner cryptoComponents.TxSig = node.OwnAccount.SingleSigner - cryptoComponents.MultiSig = node.MultiSigner + cryptoComponents.MultiSigContainer = node.MultiSigner cryptoComponents.BlKeyGen = node.OwnAccount.KeygenBlockSign cryptoComponents.TxKeyGen = node.OwnAccount.KeygenTxSign diff --git a/integrationTests/testProcessorNode.go b/integrationTests/testProcessorNode.go index 2577f90e020..b1a1c6aaf83 100644 --- a/integrationTests/testProcessorNode.go +++ b/integrationTests/testProcessorNode.go @@ -1223,7 +1223,7 @@ func (tpn *TestProcessorNode) initInterceptors(heartbeatPk string) { cryptoComponents.PubKey = nil cryptoComponents.BlockSig = tpn.OwnAccount.BlockSingleSigner cryptoComponents.TxSig = tpn.OwnAccount.SingleSigner - cryptoComponents.MultiSig = TestMultiSig + cryptoComponents.MultiSigContainer = TestMultiSig cryptoComponents.BlKeyGen = tpn.OwnAccount.KeygenBlockSign cryptoComponents.TxKeyGen = tpn.OwnAccount.KeygenTxSign @@ -2355,7 +2355,7 @@ func (tpn *TestProcessorNode) initNode() { cryptoComponents.PubKey = tpn.NodeKeys.Pk cryptoComponents.TxSig = tpn.OwnAccount.SingleSigner cryptoComponents.BlockSig = tpn.OwnAccount.SingleSigner - cryptoComponents.MultiSig = tpn.MultiSigner + cryptoComponents.MultiSigContainer = tpn.MultiSigner cryptoComponents.BlKeyGen = tpn.OwnAccount.KeygenTxSign cryptoComponents.TxKeyGen = TestKeyGenForAccounts @@ -2897,7 +2897,7 @@ func (tpn *TestProcessorNode) createHeartbeatWithHardforkTrigger() { cryptoComponents.PubKey = tpn.NodeKeys.Pk cryptoComponents.TxSig = tpn.OwnAccount.SingleSigner cryptoComponents.BlockSig = tpn.OwnAccount.SingleSigner - cryptoComponents.MultiSig = tpn.MultiSigner + cryptoComponents.MultiSigContainer = tpn.MultiSigner cryptoComponents.BlKeyGen = tpn.OwnAccount.KeygenTxSign cryptoComponents.TxKeyGen = TestKeyGenForAccounts cryptoComponents.PeerSignHandler = psh @@ -3130,18 +3130,18 @@ func GetDefaultDataComponents() *mock.DataComponentsStub { // GetDefaultCryptoComponents - func GetDefaultCryptoComponents() *mock.CryptoComponentsStub { return &mock.CryptoComponentsStub{ - PubKey: &mock.PublicKeyMock{}, - PrivKey: &mock.PrivateKeyMock{}, - PubKeyString: "pubKey", - PrivKeyBytes: []byte("privKey"), - PubKeyBytes: []byte("pubKey"), - BlockSig: &mock.SignerMock{}, - TxSig: &mock.SignerMock{}, - MultiSig: TestMultiSig, - PeerSignHandler: &mock.PeerSignatureHandler{}, - BlKeyGen: &mock.KeyGenMock{}, - TxKeyGen: &mock.KeyGenMock{}, - MsgSigVerifier: &testscommon.MessageSignVerifierMock{}, + PubKey: &mock.PublicKeyMock{}, + PrivKey: &mock.PrivateKeyMock{}, + PubKeyString: "pubKey", + PrivKeyBytes: []byte("privKey"), + PubKeyBytes: []byte("pubKey"), + BlockSig: &mock.SignerMock{}, + TxSig: &mock.SignerMock{}, + MultiSigContainer: TestMultiSig, + PeerSignHandler: &mock.PeerSignatureHandler{}, + BlKeyGen: &mock.KeyGenMock{}, + TxKeyGen: &mock.KeyGenMock{}, + MsgSigVerifier: &testscommon.MessageSignVerifierMock{}, } } diff --git a/node/mock/factory/cryptoComponentsStub.go b/node/mock/factory/cryptoComponentsStub.go index 1ed49ddc5b6..0e54fa87026 100644 --- a/node/mock/factory/cryptoComponentsStub.go +++ b/node/mock/factory/cryptoComponentsStub.go @@ -1,27 +1,29 @@ package factory import ( + "errors" "sync" "github.com/ElrondNetwork/elrond-go-crypto" + "github.com/ElrondNetwork/elrond-go/factory" "github.com/ElrondNetwork/elrond-go/vm" ) // CryptoComponentsMock - type CryptoComponentsMock struct { - PubKey crypto.PublicKey - PrivKey crypto.PrivateKey - PubKeyString string - PrivKeyBytes []byte - PubKeyBytes []byte - BlockSig crypto.SingleSigner - TxSig crypto.SingleSigner - MultiSig crypto.MultiSigner - PeerSignHandler crypto.PeerSignatureHandler - BlKeyGen crypto.KeyGenerator - TxKeyGen crypto.KeyGenerator - MsgSigVerifier vm.MessageSignVerifier - mutMultiSig sync.RWMutex + PubKey crypto.PublicKey + PrivKey crypto.PrivateKey + PubKeyString string + PrivKeyBytes []byte + PubKeyBytes []byte + BlockSig crypto.SingleSigner + TxSig crypto.SingleSigner + MultiSigContainer factory.MultiSignerContainer + PeerSignHandler crypto.PeerSignatureHandler + BlKeyGen crypto.KeyGenerator + TxKeyGen crypto.KeyGenerator + MsgSigVerifier vm.MessageSignVerifier + mutMultiSig sync.RWMutex } // Create - @@ -75,11 +77,11 @@ func (ccm *CryptoComponentsMock) TxSingleSigner() crypto.SingleSigner { } // MultiSigner - -func (ccm *CryptoComponentsMock) MultiSigner() crypto.MultiSigner { +func (ccm *CryptoComponentsMock) MultiSigner() factory.MultiSignerContainer { ccm.mutMultiSig.RLock() defer ccm.mutMultiSig.RUnlock() - return ccm.MultiSig + return ccm.MultiSigContainer } // PeerSignatureHandler - @@ -91,14 +93,26 @@ func (ccm *CryptoComponentsMock) PeerSignatureHandler() crypto.PeerSignatureHand } // SetMultiSigner - -func (ccm *CryptoComponentsMock) SetMultiSigner(ms crypto.MultiSigner) error { +func (ccm *CryptoComponentsMock) SetMultiSigner(ms factory.MultiSignerContainer) error { ccm.mutMultiSig.Lock() - ccm.MultiSig = ms + ccm.MultiSigContainer = ms ccm.mutMultiSig.Unlock() return nil } +// GetMultiSigner - +func (ccm *CryptoComponentsMock) GetMultiSigner(epoch uint32) (crypto.MultiSigner, error) { + ccm.mutMultiSig.RLock() + defer ccm.mutMultiSig.RUnlock() + + if ccm.MultiSigContainer == nil { + return nil, errors.New("nil multi sig container") + } + + return ccm.MultiSigContainer.GetMultiSigner(epoch) +} + // BlockSignKeyGen - func (ccm *CryptoComponentsMock) BlockSignKeyGen() crypto.KeyGenerator { return ccm.BlKeyGen @@ -117,19 +131,19 @@ func (ccm *CryptoComponentsMock) MessageSignVerifier() vm.MessageSignVerifier { // Clone - func (ccm *CryptoComponentsMock) Clone() interface{} { return &CryptoComponentsMock{ - PubKey: ccm.PubKey, - PrivKey: ccm.PrivKey, - PubKeyString: ccm.PubKeyString, - PrivKeyBytes: ccm.PrivKeyBytes, - PubKeyBytes: ccm.PubKeyBytes, - BlockSig: ccm.BlockSig, - TxSig: ccm.TxSig, - MultiSig: ccm.MultiSig, - PeerSignHandler: ccm.PeerSignHandler, - BlKeyGen: ccm.BlKeyGen, - TxKeyGen: ccm.TxKeyGen, - MsgSigVerifier: ccm.MsgSigVerifier, - mutMultiSig: sync.RWMutex{}, + PubKey: ccm.PubKey, + PrivKey: ccm.PrivKey, + PubKeyString: ccm.PubKeyString, + PrivKeyBytes: ccm.PrivKeyBytes, + PubKeyBytes: ccm.PubKeyBytes, + BlockSig: ccm.BlockSig, + TxSig: ccm.TxSig, + MultiSigContainer: ccm.MultiSigContainer, + PeerSignHandler: ccm.PeerSignHandler, + BlKeyGen: ccm.BlKeyGen, + TxKeyGen: ccm.TxKeyGen, + MsgSigVerifier: ccm.MsgSigVerifier, + mutMultiSig: sync.RWMutex{}, } } diff --git a/node/nodeRunner.go b/node/nodeRunner.go index dc34c2a7146..1e0d3f82801 100644 --- a/node/nodeRunner.go +++ b/node/nodeRunner.go @@ -1313,6 +1313,7 @@ func (nr *nodeRunner) CreateManagedCryptoComponents( KeyLoader: &core.KeyLoader{}, ImportModeNoSigCheck: configs.ImportDbConfig.ImportDbNoSigCheckFlag, IsInImportMode: configs.ImportDbConfig.IsImportDBMode, + EnableEpochs: configs.EpochConfig.EnableEpochs, } cryptoComponentsFactory, err := cryptoComp.NewCryptoComponentsFactory(cryptoComponentsHandlerArgs) diff --git a/process/factory/interceptorscontainer/baseInterceptorsContainerFactory.go b/process/factory/interceptorscontainer/baseInterceptorsContainerFactory.go index 8a3abe780c0..edfd14372e3 100644 --- a/process/factory/interceptorscontainer/baseInterceptorsContainerFactory.go +++ b/process/factory/interceptorscontainer/baseInterceptorsContainerFactory.go @@ -100,7 +100,11 @@ func checkBaseParams( if coreComponents.MinTransactionVersion() == 0 { return process.ErrInvalidTransactionVersion } - if check.IfNil(cryptoComponents.MultiSigner()) { + multiSigner, err := cryptoComponents.GetMultiSigner(0) + if err != nil { + return err + } + if check.IfNil(multiSigner) { return process.ErrNilMultiSigVerifier } if check.IfNil(cryptoComponents.BlockSignKeyGen()) { diff --git a/process/factory/interceptorscontainer/metaInterceptorsContainerFactory_test.go b/process/factory/interceptorscontainer/metaInterceptorsContainerFactory_test.go index dbaeaee69b2..81e0d785d79 100644 --- a/process/factory/interceptorscontainer/metaInterceptorsContainerFactory_test.go +++ b/process/factory/interceptorscontainer/metaInterceptorsContainerFactory_test.go @@ -13,6 +13,7 @@ import ( "github.com/ElrondNetwork/elrond-go/process/mock" "github.com/ElrondNetwork/elrond-go/storage" "github.com/ElrondNetwork/elrond-go/testscommon" + "github.com/ElrondNetwork/elrond-go/testscommon/cryptoMocks" dataRetrieverMock "github.com/ElrondNetwork/elrond-go/testscommon/dataRetriever" "github.com/ElrondNetwork/elrond-go/testscommon/p2pmocks" "github.com/ElrondNetwork/elrond-go/testscommon/shardingMocks" @@ -230,7 +231,7 @@ func TestNewMetaInterceptorsContainerFactory_NilMultiSignerShouldErr(t *testing. t.Parallel() coreComp, cryptoComp := createMockComponentHolders() - cryptoComp.MultiSig = nil + cryptoComp.MultiSigContainer = cryptoMocks.NewMultiSignerContainerMock(nil) args := getArgumentsMeta(coreComp, cryptoComp) icf, err := interceptorscontainer.NewMetaInterceptorsContainerFactory(args) diff --git a/process/factory/interceptorscontainer/shardInterceptorsContainerFactory_test.go b/process/factory/interceptorscontainer/shardInterceptorsContainerFactory_test.go index 826c6fbb2d9..5abc7ab2218 100644 --- a/process/factory/interceptorscontainer/shardInterceptorsContainerFactory_test.go +++ b/process/factory/interceptorscontainer/shardInterceptorsContainerFactory_test.go @@ -269,7 +269,7 @@ func TestNewShardInterceptorsContainerFactory_NilMultiSignerShouldErr(t *testing t.Parallel() coreComp, cryptoComp := createMockComponentHolders() - cryptoComp.MultiSig = nil + cryptoComp.MultiSigContainer = cryptoMocks.NewMultiSignerContainerMock(nil) args := getArgumentsShard(coreComp, cryptoComp) icf, err := interceptorscontainer.NewShardInterceptorsContainerFactory(args) @@ -685,12 +685,13 @@ func createMockComponentHolders() (*mock.CoreComponentsMock, *mock.CryptoCompone TxVersionCheckField: versioning.NewTxVersionChecker(1), HardforkTriggerPubKeyField: providedHardforkPubKey, } + multiSigner := cryptoMocks.NewMultiSigner(21) cryptoComponents := &mock.CryptoComponentsMock{ - BlockSig: &mock.SignerMock{}, - TxSig: &mock.SignerMock{}, - MultiSig: cryptoMocks.NewMultiSigner(21), - BlKeyGen: &mock.SingleSignKeyGenMock{}, - TxKeyGen: &mock.SingleSignKeyGenMock{}, + BlockSig: &mock.SignerMock{}, + TxSig: &mock.SignerMock{}, + MultiSigContainer: cryptoMocks.NewMultiSignerContainerMock(multiSigner), + BlKeyGen: &mock.SingleSignKeyGenMock{}, + TxKeyGen: &mock.SingleSignKeyGenMock{}, } return coreComponents, cryptoComponents diff --git a/process/headerCheck/headerSignatureVerify.go b/process/headerCheck/headerSignatureVerify.go index 6a6fd78d59a..4631693b76d 100644 --- a/process/headerCheck/headerSignatureVerify.go +++ b/process/headerCheck/headerSignatureVerify.go @@ -23,7 +23,7 @@ type ArgsHeaderSigVerifier struct { Marshalizer marshal.Marshalizer Hasher hashing.Hasher NodesCoordinator nodesCoordinator.NodesCoordinator - MultiSigVerifier crypto.MultiSigVerifier + MultiSigContainer process.MultiSignerContainer SingleSigVerifier crypto.SingleSigner KeyGen crypto.KeyGenerator FallbackHeaderValidator process.FallbackHeaderValidator @@ -34,7 +34,7 @@ type HeaderSigVerifier struct { marshalizer marshal.Marshalizer hasher hashing.Hasher nodesCoordinator nodesCoordinator.NodesCoordinator - multiSigVerifier crypto.MultiSigVerifier + multiSigContainer process.MultiSignerContainer singleSigVerifier crypto.SingleSigner keyGen crypto.KeyGenerator fallbackHeaderValidator process.FallbackHeaderValidator @@ -51,7 +51,7 @@ func NewHeaderSigVerifier(arguments *ArgsHeaderSigVerifier) (*HeaderSigVerifier, marshalizer: arguments.Marshalizer, hasher: arguments.Hasher, nodesCoordinator: arguments.NodesCoordinator, - multiSigVerifier: arguments.MultiSigVerifier, + multiSigContainer: arguments.MultiSigContainer, singleSigVerifier: arguments.SingleSigVerifier, keyGen: arguments.KeyGen, fallbackHeaderValidator: arguments.FallbackHeaderValidator, @@ -71,7 +71,7 @@ func checkArgsHeaderSigVerifier(arguments *ArgsHeaderSigVerifier) error { if check.IfNil(arguments.Marshalizer) { return process.ErrNilMarshalizer } - if check.IfNil(arguments.MultiSigVerifier) { + if check.IfNil(arguments.MultiSigContainer) { return process.ErrNilMultiSigVerifier } if check.IfNil(arguments.NodesCoordinator) { @@ -98,17 +98,17 @@ func (hsv *HeaderSigVerifier) VerifySignature(header data.HeaderHandler) error { return process.ErrBlockProposerSignatureMissing } - // TODO: remove if start of epoch block needs to be validated by the new epoch nodes - epoch := header.GetEpoch() - if header.IsStartOfEpochBlock() && epoch > 0 { - epoch = epoch - 1 + // TODO: remove if start of epochForConsensus block needs to be validated by the new epochForConsensus nodes + epochForConsensus := header.GetEpoch() + if header.IsStartOfEpochBlock() && epochForConsensus > 0 { + epochForConsensus = epochForConsensus - 1 } consensusPubKeys, err := hsv.nodesCoordinator.GetConsensusValidatorsPublicKeys( randSeed, header.GetRound(), header.GetShardID(), - epoch, + epochForConsensus, ) if err != nil { return err @@ -119,7 +119,12 @@ func (hsv *HeaderSigVerifier) VerifySignature(header data.HeaderHandler) error { return err } - verifier, err := hsv.multiSigVerifier.Create(consensusPubKeys, 0) + multiSigVerifier, err := hsv.multiSigContainer.GetMultiSigner(header.GetEpoch()) + if err != nil { + return err + } + + verifier, err := multiSigVerifier.Create(consensusPubKeys, 0) if err != nil { return err } diff --git a/process/interceptors/factory/argInterceptedDataFactory.go b/process/interceptors/factory/argInterceptedDataFactory.go index 3222230eba0..51323031c12 100644 --- a/process/interceptors/factory/argInterceptedDataFactory.go +++ b/process/interceptors/factory/argInterceptedDataFactory.go @@ -33,7 +33,7 @@ type interceptedDataCryptoComponentsHolder interface { BlockSignKeyGen() crypto.KeyGenerator TxSingleSigner() crypto.SingleSigner BlockSigner() crypto.SingleSigner - MultiSigner() crypto.MultiSigner + GetMultiSigner(epoch uint32) (crypto.MultiSigner, error) PublicKey() crypto.PublicKey IsInterfaceNil() bool } diff --git a/process/interceptors/factory/interceptedMetaHeaderDataFactory_test.go b/process/interceptors/factory/interceptedMetaHeaderDataFactory_test.go index 0ea3eacb074..3b3f3674a46 100644 --- a/process/interceptors/factory/interceptedMetaHeaderDataFactory_test.go +++ b/process/interceptors/factory/interceptedMetaHeaderDataFactory_test.go @@ -73,11 +73,11 @@ func createMockComponentHolders() (*mock.CoreComponentsMock, *mock.CryptoCompone HardforkTriggerPubKeyField: []byte("provided hardfork pub key"), } cryptoComponents := &mock.CryptoComponentsMock{ - BlockSig: createMockSigner(), - TxSig: createMockSigner(), - MultiSig: cryptoMocks.NewMultiSigner(21), - BlKeyGen: createMockKeyGen(), - TxKeyGen: createMockKeyGen(), + BlockSig: createMockSigner(), + TxSig: createMockSigner(), + MultiSigContainer: cryptoMocks.NewMultiSignerContainerMock(cryptoMocks.NewMultiSigner(21)), + BlKeyGen: createMockKeyGen(), + TxKeyGen: createMockKeyGen(), } return coreComponents, cryptoComponents diff --git a/process/interface.go b/process/interface.go index cfa19ce68cb..cb348a13a71 100644 --- a/process/interface.go +++ b/process/interface.go @@ -1140,14 +1140,20 @@ type CoreComponentsHolder interface { IsInterfaceNil() bool } +// MultiSignerContainer defines the container for different versioned multiSigner instances +type MultiSignerContainer interface { + GetMultiSigner(epoch uint32) (crypto.MultiSigner, error) + IsInterfaceNil() bool +} + // CryptoComponentsHolder holds the crypto components needed by the interceptors type CryptoComponentsHolder interface { TxSignKeyGen() crypto.KeyGenerator BlockSignKeyGen() crypto.KeyGenerator TxSingleSigner() crypto.SingleSigner BlockSigner() crypto.SingleSigner - MultiSigner() crypto.MultiSigner - SetMultiSigner(ms crypto.MultiSigner) error + GetMultiSigner(epoch uint32) (crypto.MultiSigner, error) + SetMultiSignerContainer(ms MultiSignerContainer) error PeerSignatureHandler() crypto.PeerSignatureHandler PublicKey() crypto.PublicKey Clone() interface{} diff --git a/process/mock/cryptoComponentsMock.go b/process/mock/cryptoComponentsMock.go index 7c74300b2e1..477305cd4be 100644 --- a/process/mock/cryptoComponentsMock.go +++ b/process/mock/cryptoComponentsMock.go @@ -1,21 +1,23 @@ package mock import ( + "errors" "sync" "github.com/ElrondNetwork/elrond-go-crypto" + "github.com/ElrondNetwork/elrond-go/process" ) // CryptoComponentsMock - type CryptoComponentsMock struct { - BlockSig crypto.SingleSigner - TxSig crypto.SingleSigner - MultiSig crypto.MultiSigner - PeerSignHandler crypto.PeerSignatureHandler - BlKeyGen crypto.KeyGenerator - TxKeyGen crypto.KeyGenerator - PubKey crypto.PublicKey - mutMultiSig sync.RWMutex + BlockSig crypto.SingleSigner + TxSig crypto.SingleSigner + MultiSigContainer process.MultiSignerContainer + PeerSignHandler crypto.PeerSignatureHandler + BlKeyGen crypto.KeyGenerator + TxKeyGen crypto.KeyGenerator + PubKey crypto.PublicKey + mutMultiSig sync.RWMutex } // BlockSigner - @@ -28,21 +30,23 @@ func (ccm *CryptoComponentsMock) TxSingleSigner() crypto.SingleSigner { return ccm.TxSig } -// MultiSigner - -func (ccm *CryptoComponentsMock) MultiSigner() crypto.MultiSigner { - ccm.mutMultiSig.RLock() - defer ccm.mutMultiSig.RUnlock() - return ccm.MultiSig -} - -// SetMultiSigner - -func (ccm *CryptoComponentsMock) SetMultiSigner(multiSigner crypto.MultiSigner) error { +// SetMultiSignerContainer - +func (ccm *CryptoComponentsMock) SetMultiSignerContainer(multiSignerContainer process.MultiSignerContainer) error { ccm.mutMultiSig.Lock() - ccm.MultiSig = multiSigner + ccm.MultiSigContainer = multiSignerContainer ccm.mutMultiSig.Unlock() return nil } +// GetMultiSigner - +func (ccm *CryptoComponentsMock) GetMultiSigner(epoch uint32) (crypto.MultiSigner, error) { + if ccm.MultiSigContainer == nil { + return nil, errors.New("nil multi signer") + } + + return ccm.MultiSigContainer.GetMultiSigner(epoch) +} + // PeerSignatureHandler returns the peer signature handler func (ccm *CryptoComponentsMock) PeerSignatureHandler() crypto.PeerSignatureHandler { ccm.mutMultiSig.RLock() @@ -69,14 +73,14 @@ func (ccm *CryptoComponentsMock) PublicKey() crypto.PublicKey { // Clone - func (ccm *CryptoComponentsMock) Clone() interface{} { return &CryptoComponentsMock{ - BlockSig: ccm.BlockSig, - TxSig: ccm.TxSig, - MultiSig: ccm.MultiSig, - PeerSignHandler: ccm.PeerSignHandler, - BlKeyGen: ccm.BlKeyGen, - TxKeyGen: ccm.TxKeyGen, - PubKey: ccm.PubKey, - mutMultiSig: sync.RWMutex{}, + BlockSig: ccm.BlockSig, + TxSig: ccm.TxSig, + MultiSigContainer: ccm.MultiSigContainer, + PeerSignHandler: ccm.PeerSignHandler, + BlKeyGen: ccm.BlKeyGen, + TxKeyGen: ccm.TxKeyGen, + PubKey: ccm.PubKey, + mutMultiSig: sync.RWMutex{}, } } diff --git a/scripts/testnet/variables.sh b/scripts/testnet/variables.sh index f9d836c2afa..44ec24b8aed 100644 --- a/scripts/testnet/variables.sh +++ b/scripts/testnet/variables.sh @@ -53,12 +53,12 @@ export OBSERVERS_ANTIFLOOD_DISABLE=0 # Shard structure export SHARDCOUNT=2 -export SHARD_VALIDATORCOUNT=3 +export SHARD_VALIDATORCOUNT=1 export SHARD_OBSERVERCOUNT=1 -export SHARD_CONSENSUS_SIZE=3 +export SHARD_CONSENSUS_SIZE=1 # Metashard structure -export META_VALIDATORCOUNT=3 +export META_VALIDATORCOUNT=1 export META_OBSERVERCOUNT=1 export META_CONSENSUS_SIZE=$META_VALIDATORCOUNT diff --git a/testscommon/cryptoMocks/multiSignerContainerMock.go b/testscommon/cryptoMocks/multiSignerContainerMock.go new file mode 100644 index 00000000000..f76dbd8236d --- /dev/null +++ b/testscommon/cryptoMocks/multiSignerContainerMock.go @@ -0,0 +1,23 @@ +package cryptoMocks + +import crypto "github.com/ElrondNetwork/elrond-go-crypto" + +// MultiSignerContainerMock - +type MultiSignerContainerMock struct { + MultiSigner crypto.MultiSigner +} + +// NewMultiSignerContainerMock - +func NewMultiSignerContainerMock(multiSigner crypto.MultiSigner) *MultiSignerContainerMock { + return &MultiSignerContainerMock{MultiSigner: multiSigner} +} + +// GetMultiSigner - +func (mscm *MultiSignerContainerMock) GetMultiSigner(_ uint32) (crypto.MultiSigner, error) { + return mscm.MultiSigner, nil +} + +// IsInterfaceNil - +func (mscm *MultiSignerContainerMock) IsInterfaceNil() bool { + return mscm == nil +} diff --git a/update/factory/exportHandlerFactory.go b/update/factory/exportHandlerFactory.go index 6accd55e2a2..c6bd0f4408b 100644 --- a/update/factory/exportHandlerFactory.go +++ b/update/factory/exportHandlerFactory.go @@ -159,7 +159,11 @@ func NewExportHandlerFactory(args ArgsExporter) (*exportHandlerFactory, error) { if check.IfNil(args.ExistingResolvers) { return nil, update.ErrNilResolverContainer } - if check.IfNil(args.CryptoComponents.MultiSigner()) { + multiSigner, err := args.CryptoComponents.GetMultiSigner(0) + if err != nil { + return nil, err + } + if check.IfNil(multiSigner) { return nil, update.ErrNilMultiSigner } if check.IfNil(args.NodesCoordinator) { @@ -219,7 +223,7 @@ func NewExportHandlerFactory(args ArgsExporter) (*exportHandlerFactory, error) { if args.NumConcurrentTrieSyncers < 1 { return nil, update.ErrInvalidNumConcurrentTrieSyncers } - err := trie.CheckTrieSyncerVersion(args.TrieSyncerVersion) + err = trie.CheckTrieSyncerVersion(args.TrieSyncerVersion) if err != nil { return nil, err } diff --git a/update/factory/fullSyncInterceptors.go b/update/factory/fullSyncInterceptors.go index 45ae6c24bd5..e76380f957c 100644 --- a/update/factory/fullSyncInterceptors.go +++ b/update/factory/fullSyncInterceptors.go @@ -248,7 +248,11 @@ func checkBaseParams( if check.IfNil(cryptoComponents.BlockSigner()) { return process.ErrNilSingleSigner } - if check.IfNil(cryptoComponents.MultiSigner()) { + multiSigner, err := cryptoComponents.GetMultiSigner(0) + if err != nil { + return err + } + if check.IfNil(multiSigner) { return process.ErrNilMultiSigVerifier } if check.IfNil(shardCoordinator) { From 03ce6996d85efcba4d63d77a71e95e2cad3d7f08 Mon Sep 17 00:00:00 2001 From: AdoAdoAdo Date: Wed, 20 Jul 2022 14:49:17 +0300 Subject: [PATCH 02/10] move MultiSignerContainer interface to common and fix tests --- common/crypto/interface.go | 9 +++ consensus/mock/consensusDataContainerMock.go | 15 ++--- consensus/mock/mockTestInitializer.go | 3 +- consensus/spos/consensusCore.go | 9 +-- consensus/spos/consensusCoreValidator_test.go | 3 +- consensus/spos/interface.go | 3 +- epochStart/mock/cryptoComponentsMock.go | 60 ++++++++++++------- errors/errors.go | 3 + factory/crypto/cryptoComponents.go | 5 +- factory/crypto/cryptoComponentsHandler.go | 39 +++++------- factory/crypto/export_test.go | 4 +- factory/interface.go | 11 +--- factory/mock/cryptoComponentsMock.go | 28 ++++----- integrationTests/mock/cryptoComponentsStub.go | 18 +++--- node/mock/factory/cryptoComponentsStub.go | 28 ++++----- process/errors.go | 3 + process/headerCheck/headerSignatureVerify.go | 12 +++- .../headerCheck/headerSignatureVerify_test.go | 24 ++++---- process/interface.go | 10 +--- process/mock/cryptoComponentsMock.go | 34 +++++++---- 20 files changed, 180 insertions(+), 141 deletions(-) create mode 100644 common/crypto/interface.go diff --git a/common/crypto/interface.go b/common/crypto/interface.go new file mode 100644 index 00000000000..3e7f1bbeb6f --- /dev/null +++ b/common/crypto/interface.go @@ -0,0 +1,9 @@ +package crypto + +import crypto "github.com/ElrondNetwork/elrond-go-crypto" + +// MultiSignerContainer defines the container for different versioned multiSigner instances +type MultiSignerContainer interface { + GetMultiSigner(epoch uint32) (crypto.MultiSigner, error) + IsInterfaceNil() bool +} diff --git a/consensus/mock/consensusDataContainerMock.go b/consensus/mock/consensusDataContainerMock.go index 0382d83a694..d44c3704589 100644 --- a/consensus/mock/consensusDataContainerMock.go +++ b/consensus/mock/consensusDataContainerMock.go @@ -5,6 +5,7 @@ import ( "github.com/ElrondNetwork/elrond-go-core/hashing" "github.com/ElrondNetwork/elrond-go-core/marshal" crypto "github.com/ElrondNetwork/elrond-go-crypto" + cryptoCommon "github.com/ElrondNetwork/elrond-go/common/crypto" "github.com/ElrondNetwork/elrond-go/consensus" "github.com/ElrondNetwork/elrond-go/epochStart" "github.com/ElrondNetwork/elrond-go/ntp" @@ -25,7 +26,7 @@ type ConsensusCoreMock struct { marshalizer marshal.Marshalizer blsPrivateKey crypto.PrivateKey blsSingleSigner crypto.SingleSigner - multiSigner crypto.MultiSigner + multiSignerContainer cryptoCommon.MultiSignerContainer roundHandler consensus.RoundHandler shardCoordinator sharding.Coordinator syncTimer ntp.SyncTimer @@ -84,9 +85,9 @@ func (ccm *ConsensusCoreMock) Marshalizer() marshal.Marshalizer { return ccm.marshalizer } -// MultiSigner - -func (ccm *ConsensusCoreMock) MultiSignerContainer() process.MultiSignerContainer { - return ccm.multiSigner +// MultiSignerContainer - +func (ccm *ConsensusCoreMock) MultiSignerContainer() cryptoCommon.MultiSignerContainer { + return ccm.multiSignerContainer } // RoundHandler - @@ -154,9 +155,9 @@ func (ccm *ConsensusCoreMock) SetMarshalizer(marshalizer marshal.Marshalizer) { ccm.marshalizer = marshalizer } -// SetMultiSigner - -func (ccm *ConsensusCoreMock) SetMultiSigner(multiSigner crypto.MultiSigner) { - ccm.multiSigner = multiSigner +// SetMultiSignerContainer - +func (ccm *ConsensusCoreMock) SetMultiSignerContainer(multiSigner cryptoCommon.MultiSignerContainer) { + ccm.multiSignerContainer = multiSigner } // SetRoundHandler - diff --git a/consensus/mock/mockTestInitializer.go b/consensus/mock/mockTestInitializer.go index 18a3c006025..0757191fe0c 100644 --- a/consensus/mock/mockTestInitializer.go +++ b/consensus/mock/mockTestInitializer.go @@ -204,6 +204,7 @@ func InitConsensusCoreWithMultiSigner(multiSigner crypto.MultiSigner) *Consensus fallbackHeaderValidator := &testscommon.FallBackHeaderValidatorStub{} nodeRedundancyHandler := &NodeRedundancyHandlerStub{} scheduledProcessor := &consensusMocks.ScheduledProcessorStub{} + multiSignerContainer := cryptoMocks.NewMultiSignerContainerMock(multiSigner) container := &ConsensusCoreMock{ blockChain: blockChain, @@ -216,7 +217,7 @@ func InitConsensusCoreWithMultiSigner(multiSigner crypto.MultiSigner) *Consensus marshalizer: marshalizerMock, blsPrivateKey: blsPrivateKeyMock, blsSingleSigner: blsSingleSignerMock, - multiSigner: multiSigner, + multiSignerContainer: multiSignerContainer, roundHandler: roundHandlerMock, shardCoordinator: shardCoordinatorMock, syncTimer: syncTimerMock, diff --git a/consensus/spos/consensusCore.go b/consensus/spos/consensusCore.go index 752d7565810..e08c9724133 100644 --- a/consensus/spos/consensusCore.go +++ b/consensus/spos/consensusCore.go @@ -5,6 +5,7 @@ import ( "github.com/ElrondNetwork/elrond-go-core/hashing" "github.com/ElrondNetwork/elrond-go-core/marshal" crypto "github.com/ElrondNetwork/elrond-go-crypto" + cryptoCommon "github.com/ElrondNetwork/elrond-go/common/crypto" "github.com/ElrondNetwork/elrond-go/consensus" "github.com/ElrondNetwork/elrond-go/epochStart" "github.com/ElrondNetwork/elrond-go/ntp" @@ -25,7 +26,7 @@ type ConsensusCore struct { marshalizer marshal.Marshalizer blsPrivateKey crypto.PrivateKey blsSingleSigner crypto.SingleSigner - multiSignerContainer process.MultiSignerContainer + multiSignerContainer cryptoCommon.MultiSignerContainer roundHandler consensus.RoundHandler shardCoordinator sharding.Coordinator nodesCoordinator nodesCoordinator.NodesCoordinator @@ -50,7 +51,7 @@ type ConsensusCoreArgs struct { Marshalizer marshal.Marshalizer BlsPrivateKey crypto.PrivateKey BlsSingleSigner crypto.SingleSigner - MultiSignerContainer process.MultiSignerContainer + MultiSignerContainer cryptoCommon.MultiSignerContainer RoundHandler consensus.RoundHandler ShardCoordinator sharding.Coordinator NodesCoordinator nodesCoordinator.NodesCoordinator @@ -140,8 +141,8 @@ func (cc *ConsensusCore) Marshalizer() marshal.Marshalizer { return cc.marshalizer } -// MultiSigner gets the MultiSigner stored in the ConsensusCore -func (cc *ConsensusCore) MultiSignerContainer() process.MultiSignerContainer { +// MultiSignerContainer gets the MultiSigner stored in the ConsensusCore +func (cc *ConsensusCore) MultiSignerContainer() cryptoCommon.MultiSignerContainer { return cc.multiSignerContainer } diff --git a/consensus/spos/consensusCoreValidator_test.go b/consensus/spos/consensusCoreValidator_test.go index cc4c15e99f6..b750b1af313 100644 --- a/consensus/spos/consensusCoreValidator_test.go +++ b/consensus/spos/consensusCoreValidator_test.go @@ -31,6 +31,7 @@ func initConsensusDataContainer() *ConsensusCore { headerSigVerifier := &mock.HeaderSigVerifierStub{} fallbackHeaderValidator := &testscommon.FallBackHeaderValidatorStub{} nodeRedundancyHandler := &mock.NodeRedundancyHandlerStub{} + multiSignerContainer := cryptoMocks.NewMultiSignerContainerMock(multiSignerMock) return &ConsensusCore{ blockChain: blockChain, @@ -42,7 +43,7 @@ func initConsensusDataContainer() *ConsensusCore { marshalizer: marshalizerMock, blsPrivateKey: blsPrivateKeyMock, blsSingleSigner: blsSingleSignerMock, - multiSignerContainer: multiSignerMock, + multiSignerContainer: multiSignerContainer, roundHandler: roundHandlerMock, shardCoordinator: shardCoordinatorMock, syncTimer: syncTimerMock, diff --git a/consensus/spos/interface.go b/consensus/spos/interface.go index 6906ac9d077..170d47490eb 100644 --- a/consensus/spos/interface.go +++ b/consensus/spos/interface.go @@ -9,6 +9,7 @@ import ( "github.com/ElrondNetwork/elrond-go-core/hashing" "github.com/ElrondNetwork/elrond-go-core/marshal" crypto "github.com/ElrondNetwork/elrond-go-crypto" + cryptoCommon "github.com/ElrondNetwork/elrond-go/common/crypto" "github.com/ElrondNetwork/elrond-go/consensus" "github.com/ElrondNetwork/elrond-go/epochStart" "github.com/ElrondNetwork/elrond-go/ntp" @@ -37,7 +38,7 @@ type ConsensusCoreHandler interface { // Marshalizer gets the Marshalizer stored in the ConsensusCore Marshalizer() marshal.Marshalizer // MultiSignerContainer gets the MultiSigner container from the ConsensusCore - MultiSignerContainer() process.MultiSignerContainer + MultiSignerContainer() cryptoCommon.MultiSignerContainer // RoundHandler gets the RoundHandler stored in the ConsensusCore RoundHandler() consensus.RoundHandler // ShardCoordinator gets the ShardCoordinator stored in the ConsensusCore diff --git a/epochStart/mock/cryptoComponentsMock.go b/epochStart/mock/cryptoComponentsMock.go index afbcb00a382..1d65646728c 100644 --- a/epochStart/mock/cryptoComponentsMock.go +++ b/epochStart/mock/cryptoComponentsMock.go @@ -1,21 +1,23 @@ package mock import ( + "errors" "sync" "github.com/ElrondNetwork/elrond-go-crypto" + cryptoCommon "github.com/ElrondNetwork/elrond-go/common/crypto" ) // CryptoComponentsMock - type CryptoComponentsMock struct { - PubKey crypto.PublicKey - BlockSig crypto.SingleSigner - TxSig crypto.SingleSigner - MultiSig crypto.MultiSigner - PeerSignHandler crypto.PeerSignatureHandler - BlKeyGen crypto.KeyGenerator - TxKeyGen crypto.KeyGenerator - mutCrypto sync.RWMutex + PubKey crypto.PublicKey + BlockSig crypto.SingleSigner + TxSig crypto.SingleSigner + MultiSigContainer cryptoCommon.MultiSignerContainer + PeerSignHandler crypto.PeerSignatureHandler + BlKeyGen crypto.KeyGenerator + TxKeyGen crypto.KeyGenerator + mutCrypto sync.RWMutex } // PublicKey - @@ -33,20 +35,32 @@ func (ccm *CryptoComponentsMock) TxSingleSigner() crypto.SingleSigner { return ccm.TxSig } -// MultiSigner - -func (ccm *CryptoComponentsMock) MultiSigner() crypto.MultiSigner { +// GetMultiSigner - +func (ccm *CryptoComponentsMock) GetMultiSigner(epoch uint32) (crypto.MultiSigner, error) { ccm.mutCrypto.RLock() defer ccm.mutCrypto.RUnlock() - return ccm.MultiSig + if ccm.MultiSigContainer == nil { + return nil, errors.New("multisigner container is nil") + } + + return ccm.MultiSigContainer.GetMultiSigner(epoch) +} + +// MultiSignerContainer - +func (ccm *CryptoComponentsMock) MultiSignerContainer() cryptoCommon.MultiSignerContainer { + ccm.mutCrypto.RLock() + defer ccm.mutCrypto.RUnlock() + + return ccm.MultiSigContainer } -// SetMultiSigner - -func (ccm *CryptoComponentsMock) SetMultiSigner(m crypto.MultiSigner) error { +// SetMultiSignerContainer - +func (ccm *CryptoComponentsMock) SetMultiSignerContainer(msc cryptoCommon.MultiSignerContainer) error { ccm.mutCrypto.Lock() - ccm.MultiSig = m - ccm.mutCrypto.Unlock() + defer ccm.mutCrypto.Unlock() + ccm.MultiSigContainer = msc return nil } @@ -68,14 +82,14 @@ func (ccm *CryptoComponentsMock) TxSignKeyGen() crypto.KeyGenerator { // Clone - func (ccm *CryptoComponentsMock) Clone() interface{} { return &CryptoComponentsMock{ - PubKey: ccm.PubKey, - BlockSig: ccm.BlockSig, - TxSig: ccm.TxSig, - MultiSig: ccm.MultiSig, - PeerSignHandler: ccm.PeerSignHandler, - BlKeyGen: ccm.BlKeyGen, - TxKeyGen: ccm.TxKeyGen, - mutCrypto: sync.RWMutex{}, + PubKey: ccm.PubKey, + BlockSig: ccm.BlockSig, + TxSig: ccm.TxSig, + MultiSigContainer: ccm.MultiSigContainer, + PeerSignHandler: ccm.PeerSignHandler, + BlKeyGen: ccm.BlKeyGen, + TxKeyGen: ccm.TxKeyGen, + mutCrypto: sync.RWMutex{}, } } diff --git a/errors/errors.go b/errors/errors.go index 6d131f073d3..7c9e2344d2c 100644 --- a/errors/errors.go +++ b/errors/errors.go @@ -484,3 +484,6 @@ var ErrSignerNotSupported = errors.New("signer not supported") // ErrMissingMultiSignerConfig signals that the multisigner config is missing var ErrMissingMultiSignerConfig = errors.New("multisigner configuration missing") + +// ErrNilMultiSignerContainer signals that the multisigner container is nil +var ErrNilMultiSignerContainer = errors.New("multisigner container is nil") diff --git a/factory/crypto/cryptoComponents.go b/factory/crypto/cryptoComponents.go index cbf6be11e4d..2cb9d1f7d41 100644 --- a/factory/crypto/cryptoComponents.go +++ b/factory/crypto/cryptoComponents.go @@ -19,6 +19,7 @@ import ( mclSig "github.com/ElrondNetwork/elrond-go-crypto/signing/mcl/singlesig" "github.com/ElrondNetwork/elrond-go-crypto/signing/multisig" logger "github.com/ElrondNetwork/elrond-go-logger" + cryptoCommon "github.com/ElrondNetwork/elrond-go/common/crypto" "github.com/ElrondNetwork/elrond-go/config" "github.com/ElrondNetwork/elrond-go/consensus" "github.com/ElrondNetwork/elrond-go/errors" @@ -72,7 +73,7 @@ type cryptoParams struct { type cryptoComponents struct { txSingleSigner crypto.SingleSigner blockSingleSigner crypto.SingleSigner - multiSignerContainer factory.MultiSignerContainer + multiSignerContainer cryptoCommon.MultiSignerContainer peerSignHandler crypto.PeerSignatureHandler blockSignKeyGen crypto.KeyGenerator txSignKeyGen crypto.KeyGenerator @@ -223,7 +224,7 @@ func (ccf *cryptoComponentsFactory) createMultiSignerContainer( cp *cryptoParams, blSignKeyGen crypto.KeyGenerator, importModeNoSigCheck bool, -) (factory.MultiSignerContainer, error) { +) (cryptoCommon.MultiSignerContainer, error) { args := MultiSigArgs{ hasher: hasher, diff --git a/factory/crypto/cryptoComponentsHandler.go b/factory/crypto/cryptoComponentsHandler.go index a8f30109ab7..4cc0c082711 100644 --- a/factory/crypto/cryptoComponentsHandler.go +++ b/factory/crypto/cryptoComponentsHandler.go @@ -6,6 +6,7 @@ import ( "github.com/ElrondNetwork/elrond-go-core/core/check" "github.com/ElrondNetwork/elrond-go-crypto" + cryptoCommon "github.com/ElrondNetwork/elrond-go/common/crypto" "github.com/ElrondNetwork/elrond-go/errors" "github.com/ElrondNetwork/elrond-go/factory" "github.com/ElrondNetwork/elrond-go/vm" @@ -193,28 +194,33 @@ func (mcc *managedCryptoComponents) BlockSigner() crypto.SingleSigner { return mcc.cryptoComponents.blockSingleSigner } -// MultiSignerContainer returns the block multi-signer container -func (mcc *managedCryptoComponents) MultiSignerContainer() factory.MultiSignerContainer { +// MultiSignerContainer - +func (mcc *managedCryptoComponents) MultiSignerContainer() cryptoCommon.MultiSignerContainer { mcc.mutCryptoComponents.RLock() defer mcc.mutCryptoComponents.RUnlock() - if mcc.cryptoComponents == nil { - return nil - } + return mcc.multiSignerContainer +} + +// SetMultiSignerContainer - +func (mcc *managedCryptoComponents) SetMultiSignerContainer(ms cryptoCommon.MultiSignerContainer) error { + mcc.mutCryptoComponents.Lock() + mcc.multiSignerContainer = ms + mcc.mutCryptoComponents.Unlock() - return mcc.cryptoComponents.multiSignerContainer + return nil } -// GetMultiSigner returns the block multi signer valid for the given epoch +// GetMultiSigner - func (mcc *managedCryptoComponents) GetMultiSigner(epoch uint32) (crypto.MultiSigner, error) { mcc.mutCryptoComponents.RLock() defer mcc.mutCryptoComponents.RUnlock() - if mcc.cryptoComponents == nil { - return nil, errors.ErrNilCryptoComponents + if mcc.multiSignerContainer == nil { + return nil, errors.ErrNilMultiSignerContainer } - return mcc.cryptoComponents.multiSignerContainer.GetMultiSigner(epoch) + return mcc.MultiSignerContainer().GetMultiSigner(epoch) } // PeerSignatureHandler returns the peer signature handler @@ -229,19 +235,6 @@ func (mcc *managedCryptoComponents) PeerSignatureHandler() crypto.PeerSignatureH return mcc.cryptoComponents.peerSignHandler } -// SetMultiSignerContainer sets the block multi-signer container -func (mcc *managedCryptoComponents) SetMultiSignerContainer(ms factory.MultiSignerContainer) error { - mcc.mutCryptoComponents.Lock() - defer mcc.mutCryptoComponents.Unlock() - - if mcc.cryptoComponents == nil { - return errors.ErrNilCryptoComponents - } - - mcc.cryptoComponents.multiSignerContainer = ms - return nil -} - // BlockSignKeyGen returns the block signer key generator func (mcc *managedCryptoComponents) BlockSignKeyGen() crypto.KeyGenerator { mcc.mutCryptoComponents.RLock() diff --git a/factory/crypto/export_test.go b/factory/crypto/export_test.go index 73df2f5836c..402769d3f13 100644 --- a/factory/crypto/export_test.go +++ b/factory/crypto/export_test.go @@ -3,7 +3,7 @@ package crypto import ( "github.com/ElrondNetwork/elrond-go-core/hashing" crypto "github.com/ElrondNetwork/elrond-go-crypto" - "github.com/ElrondNetwork/elrond-go/factory" + cryptoCommon "github.com/ElrondNetwork/elrond-go/common/crypto" ) // GetSkPk - @@ -34,7 +34,7 @@ func (ccf *cryptoComponentsFactory) CreateCryptoParams(blockSignKeyGen crypto.Ke // CreateMultiSignerContainer - func (ccf *cryptoComponentsFactory) CreateMultiSignerContainer( h hashing.Hasher, cp *cryptoParams, blSignKeyGen crypto.KeyGenerator, importModeNoSigCheck bool, -) (factory.MultiSignerContainer, error) { +) (cryptoCommon.MultiSignerContainer, error) { return ccf.createMultiSignerContainer(h, cp, blSignKeyGen, importModeNoSigCheck) } diff --git a/factory/interface.go b/factory/interface.go index adbf49cee49..aa33e2ad45b 100644 --- a/factory/interface.go +++ b/factory/interface.go @@ -16,6 +16,7 @@ import ( crypto "github.com/ElrondNetwork/elrond-go-crypto" "github.com/ElrondNetwork/elrond-go/cmd/node/factory" "github.com/ElrondNetwork/elrond-go/common" + cryptoCommon "github.com/ElrondNetwork/elrond-go/common/crypto" "github.com/ElrondNetwork/elrond-go/common/statistics" "github.com/ElrondNetwork/elrond-go/consensus" "github.com/ElrondNetwork/elrond-go/dataRetriever" @@ -150,19 +151,13 @@ type CryptoParamsHolder interface { PrivateKeyBytes() []byte } -// MultiSignerContainer defines the container for different versioned multiSigner instances -type MultiSignerContainer interface { - GetMultiSigner(epoch uint32) (crypto.MultiSigner, error) - IsInterfaceNil() bool -} - // CryptoComponentsHolder holds the crypto components type CryptoComponentsHolder interface { CryptoParamsHolder TxSingleSigner() crypto.SingleSigner BlockSigner() crypto.SingleSigner - SetMultiSignerContainer(container MultiSignerContainer) error - MultiSignerContainer() MultiSignerContainer + SetMultiSignerContainer(container cryptoCommon.MultiSignerContainer) error + MultiSignerContainer() cryptoCommon.MultiSignerContainer GetMultiSigner(epoch uint32) (crypto.MultiSigner, error) PeerSignatureHandler() crypto.PeerSignatureHandler BlockSignKeyGen() crypto.KeyGenerator diff --git a/factory/mock/cryptoComponentsMock.go b/factory/mock/cryptoComponentsMock.go index 51ecd42b7d6..6e200f40e26 100644 --- a/factory/mock/cryptoComponentsMock.go +++ b/factory/mock/cryptoComponentsMock.go @@ -5,7 +5,7 @@ import ( "sync" "github.com/ElrondNetwork/elrond-go-crypto" - "github.com/ElrondNetwork/elrond-go/factory" + cryptoCommon "github.com/ElrondNetwork/elrond-go/common/crypto" "github.com/ElrondNetwork/elrond-go/vm" ) @@ -18,7 +18,7 @@ type CryptoComponentsMock struct { PubKeyBytes []byte BlockSig crypto.SingleSigner TxSig crypto.SingleSigner - MultiSigContainer factory.MultiSignerContainer + MultiSigContainer cryptoCommon.MultiSignerContainer PeerSignHandler crypto.PeerSignatureHandler BlKeyGen crypto.KeyGenerator TxKeyGen crypto.KeyGenerator @@ -62,19 +62,20 @@ func (ccm *CryptoComponentsMock) TxSingleSigner() crypto.SingleSigner { } // MultiSignerContainer - -func (ccm *CryptoComponentsMock) MultiSignerContainer() factory.MultiSignerContainer { +func (ccm *CryptoComponentsMock) MultiSignerContainer() cryptoCommon.MultiSignerContainer { ccm.mutMultiSig.RLock() defer ccm.mutMultiSig.RUnlock() return ccm.MultiSigContainer } -// PeerSignatureHandler - -func (ccm *CryptoComponentsMock) PeerSignatureHandler() crypto.PeerSignatureHandler { - ccm.mutMultiSig.RLock() - defer ccm.mutMultiSig.RUnlock() +// SetMultiSignerContainer - +func (ccm *CryptoComponentsMock) SetMultiSignerContainer(ms cryptoCommon.MultiSignerContainer) error { + ccm.mutMultiSig.Lock() + ccm.MultiSigContainer = ms + ccm.mutMultiSig.Unlock() - return ccm.PeerSignHandler + return nil } // GetMultiSigner - @@ -89,13 +90,12 @@ func (ccm *CryptoComponentsMock) GetMultiSigner(epoch uint32) (crypto.MultiSigne return ccm.MultiSigContainer.GetMultiSigner(epoch) } -// SetMultiSignerContainer - -func (ccm *CryptoComponentsMock) SetMultiSignerContainer(ms factory.MultiSignerContainer) error { - ccm.mutMultiSig.Lock() - ccm.MultiSigContainer = ms - ccm.mutMultiSig.Unlock() +// PeerSignatureHandler - +func (ccm *CryptoComponentsMock) PeerSignatureHandler() crypto.PeerSignatureHandler { + ccm.mutMultiSig.RLock() + defer ccm.mutMultiSig.RUnlock() - return nil + return ccm.PeerSignHandler } // BlockSignKeyGen - diff --git a/integrationTests/mock/cryptoComponentsStub.go b/integrationTests/mock/cryptoComponentsStub.go index 6e93e49805f..f855b8e9e50 100644 --- a/integrationTests/mock/cryptoComponentsStub.go +++ b/integrationTests/mock/cryptoComponentsStub.go @@ -5,7 +5,7 @@ import ( "sync" "github.com/ElrondNetwork/elrond-go-crypto" - "github.com/ElrondNetwork/elrond-go/factory" + cryptoCommon "github.com/ElrondNetwork/elrond-go/common/crypto" "github.com/ElrondNetwork/elrond-go/vm" ) @@ -18,7 +18,7 @@ type CryptoComponentsStub struct { PubKeyBytes []byte BlockSig crypto.SingleSigner TxSig crypto.SingleSigner - MultiSigContainer factory.MultiSignerContainer + MultiSigContainer cryptoCommon.MultiSignerContainer PeerSignHandler crypto.PeerSignatureHandler BlKeyGen crypto.KeyGenerator TxKeyGen crypto.KeyGenerator @@ -76,24 +76,24 @@ func (ccs *CryptoComponentsStub) TxSingleSigner() crypto.SingleSigner { return ccs.TxSig } -// MultiSignerContainer - -func (ccs *CryptoComponentsStub) MultiSignerContainer() factory.MultiSignerContainer { +// PeerSignatureHandler - +func (ccs *CryptoComponentsStub) PeerSignatureHandler() crypto.PeerSignatureHandler { ccs.mutMultiSig.RLock() defer ccs.mutMultiSig.RUnlock() - return ccs.MultiSigContainer + return ccs.PeerSignHandler } -// PeerSignatureHandler - -func (ccs *CryptoComponentsStub) PeerSignatureHandler() crypto.PeerSignatureHandler { +// MultiSignerContainer - +func (ccs *CryptoComponentsStub) MultiSignerContainer() cryptoCommon.MultiSignerContainer { ccs.mutMultiSig.RLock() defer ccs.mutMultiSig.RUnlock() - return ccs.PeerSignHandler + return ccs.MultiSigContainer } // SetMultiSignerContainer - -func (ccs *CryptoComponentsStub) SetMultiSignerContainer(ms factory.MultiSignerContainer) error { +func (ccs *CryptoComponentsStub) SetMultiSignerContainer(ms cryptoCommon.MultiSignerContainer) error { ccs.mutMultiSig.Lock() ccs.MultiSigContainer = ms ccs.mutMultiSig.Unlock() diff --git a/node/mock/factory/cryptoComponentsStub.go b/node/mock/factory/cryptoComponentsStub.go index 0e54fa87026..40e94e95775 100644 --- a/node/mock/factory/cryptoComponentsStub.go +++ b/node/mock/factory/cryptoComponentsStub.go @@ -5,7 +5,7 @@ import ( "sync" "github.com/ElrondNetwork/elrond-go-crypto" - "github.com/ElrondNetwork/elrond-go/factory" + cryptoCommon "github.com/ElrondNetwork/elrond-go/common/crypto" "github.com/ElrondNetwork/elrond-go/vm" ) @@ -18,7 +18,7 @@ type CryptoComponentsMock struct { PubKeyBytes []byte BlockSig crypto.SingleSigner TxSig crypto.SingleSigner - MultiSigContainer factory.MultiSignerContainer + MultiSigContainer cryptoCommon.MultiSignerContainer PeerSignHandler crypto.PeerSignatureHandler BlKeyGen crypto.KeyGenerator TxKeyGen crypto.KeyGenerator @@ -76,24 +76,16 @@ func (ccm *CryptoComponentsMock) TxSingleSigner() crypto.SingleSigner { return ccm.TxSig } -// MultiSigner - -func (ccm *CryptoComponentsMock) MultiSigner() factory.MultiSignerContainer { +// MultiSignerContainer - +func (ccm *CryptoComponentsMock) MultiSignerContainer() cryptoCommon.MultiSignerContainer { ccm.mutMultiSig.RLock() defer ccm.mutMultiSig.RUnlock() return ccm.MultiSigContainer } -// PeerSignatureHandler - -func (ccm *CryptoComponentsMock) PeerSignatureHandler() crypto.PeerSignatureHandler { - ccm.mutMultiSig.RLock() - defer ccm.mutMultiSig.RUnlock() - - return ccm.PeerSignHandler -} - -// SetMultiSigner - -func (ccm *CryptoComponentsMock) SetMultiSigner(ms factory.MultiSignerContainer) error { +// SetMultiSignerContainer - +func (ccm *CryptoComponentsMock) SetMultiSignerContainer(ms cryptoCommon.MultiSignerContainer) error { ccm.mutMultiSig.Lock() ccm.MultiSigContainer = ms ccm.mutMultiSig.Unlock() @@ -113,6 +105,14 @@ func (ccm *CryptoComponentsMock) GetMultiSigner(epoch uint32) (crypto.MultiSigne return ccm.MultiSigContainer.GetMultiSigner(epoch) } +// PeerSignatureHandler - +func (ccm *CryptoComponentsMock) PeerSignatureHandler() crypto.PeerSignatureHandler { + ccm.mutMultiSig.RLock() + defer ccm.mutMultiSig.RUnlock() + + return ccm.PeerSignHandler +} + // BlockSignKeyGen - func (ccm *CryptoComponentsMock) BlockSignKeyGen() crypto.KeyGenerator { return ccm.BlKeyGen diff --git a/process/errors.go b/process/errors.go index fb8b91e27f9..e996919da1c 100644 --- a/process/errors.go +++ b/process/errors.go @@ -1133,3 +1133,6 @@ var ErrNilProcessedMiniBlocksTracker = errors.New("nil processed mini blocks tra // ErrNilESDTGlobalSettingsHandler signals that nil global settings handler was provided var ErrNilESDTGlobalSettingsHandler = errors.New("nil esdt global settings handler") + +// ErrNilMultiSignerContainer signals that the given multisigner container is nil +var ErrNilMultiSignerContainer = errors.New("nil multiSigner container") diff --git a/process/headerCheck/headerSignatureVerify.go b/process/headerCheck/headerSignatureVerify.go index 4631693b76d..601ea5b1dd5 100644 --- a/process/headerCheck/headerSignatureVerify.go +++ b/process/headerCheck/headerSignatureVerify.go @@ -10,6 +10,7 @@ import ( "github.com/ElrondNetwork/elrond-go-core/marshal" crypto "github.com/ElrondNetwork/elrond-go-crypto" logger "github.com/ElrondNetwork/elrond-go-logger" + cryptoCommon "github.com/ElrondNetwork/elrond-go/common/crypto" "github.com/ElrondNetwork/elrond-go/process" "github.com/ElrondNetwork/elrond-go/sharding/nodesCoordinator" ) @@ -23,7 +24,7 @@ type ArgsHeaderSigVerifier struct { Marshalizer marshal.Marshalizer Hasher hashing.Hasher NodesCoordinator nodesCoordinator.NodesCoordinator - MultiSigContainer process.MultiSignerContainer + MultiSigContainer cryptoCommon.MultiSignerContainer SingleSigVerifier crypto.SingleSigner KeyGen crypto.KeyGenerator FallbackHeaderValidator process.FallbackHeaderValidator @@ -34,7 +35,7 @@ type HeaderSigVerifier struct { marshalizer marshal.Marshalizer hasher hashing.Hasher nodesCoordinator nodesCoordinator.NodesCoordinator - multiSigContainer process.MultiSignerContainer + multiSigContainer cryptoCommon.MultiSignerContainer singleSigVerifier crypto.SingleSigner keyGen crypto.KeyGenerator fallbackHeaderValidator process.FallbackHeaderValidator @@ -72,6 +73,13 @@ func checkArgsHeaderSigVerifier(arguments *ArgsHeaderSigVerifier) error { return process.ErrNilMarshalizer } if check.IfNil(arguments.MultiSigContainer) { + return process.ErrNilMultiSignerContainer + } + multiSigner, err := arguments.MultiSigContainer.GetMultiSigner(0) + if err != nil { + return err + } + if check.IfNil(multiSigner) { return process.ErrNilMultiSigVerifier } if check.IfNil(arguments.NodesCoordinator) { diff --git a/process/headerCheck/headerSignatureVerify_test.go b/process/headerCheck/headerSignatureVerify_test.go index 2f0401375cf..519f9a7a6ed 100644 --- a/process/headerCheck/headerSignatureVerify_test.go +++ b/process/headerCheck/headerSignatureVerify_test.go @@ -25,7 +25,7 @@ func createHeaderSigVerifierArgs() *ArgsHeaderSigVerifier { Marshalizer: &mock.MarshalizerMock{}, Hasher: &hashingMocks.HasherMock{}, NodesCoordinator: &shardingMocks.NodesCoordinatorMock{}, - MultiSigVerifier: cryptoMocks.NewMultiSigner(21), + MultiSigContainer: cryptoMocks.NewMultiSignerContainerMock(cryptoMocks.NewMultiSigner(21)), SingleSigVerifier: &mock.SignerMock{}, KeyGen: &mock.SingleSignKeyGenMock{}, FallbackHeaderValidator: &testscommon.FallBackHeaderValidatorStub{}, @@ -78,7 +78,7 @@ func TestNewHeaderSigVerifier_NilMultiSigShouldErr(t *testing.T) { t.Parallel() args := createHeaderSigVerifierArgs() - args.MultiSigVerifier = nil + args.MultiSigContainer = cryptoMocks.NewMultiSignerContainerMock(nil) hdrSigVerifier, err := NewHeaderSigVerifier(args) require.Nil(t, hdrSigVerifier) @@ -527,15 +527,15 @@ func TestHeaderSigVerifier_VerifySignatureOk(t *testing.T) { wasCalled := false args := createHeaderSigVerifierArgs() pkAddr := []byte("aaa00000000000000000000000000000") - nodesCoordinator := &shardingMocks.NodesCoordinatorMock{ + nc := &shardingMocks.NodesCoordinatorMock{ ComputeValidatorsGroupCalled: func(randomness []byte, round uint64, shardId uint32, epoch uint32) (validators []nodesCoordinator.Validator, err error) { v, _ := nodesCoordinator.NewValidator(pkAddr, 1, defaultChancesSelection) return []nodesCoordinator.Validator{v}, nil }, } - args.NodesCoordinator = nodesCoordinator + args.NodesCoordinator = nc - args.MultiSigVerifier = &cryptoMocks.MultisignerMock{ + args.MultiSigContainer = cryptoMocks.NewMultiSignerContainerMock(&cryptoMocks.MultisignerMock{ CreateCalled: func(pubKeys []string, index uint16) (signer crypto.MultiSigner, err error) { return &cryptoMocks.MultisignerMock{ VerifyCalled: func(msg []byte, bitmap []byte) error { @@ -543,7 +543,7 @@ func TestHeaderSigVerifier_VerifySignatureOk(t *testing.T) { return nil }}, nil }, - } + }) hdrSigVerifier, _ := NewHeaderSigVerifier(args) header := &dataBlock.Header{ @@ -561,7 +561,7 @@ func TestHeaderSigVerifier_VerifySignatureNotEnoughSigsShouldErrWhenFallbackThre wasCalled := false args := createHeaderSigVerifierArgs() pkAddr := []byte("aaa00000000000000000000000000000") - nodesCoordinator := &shardingMocks.NodesCoordinatorMock{ + nc := &shardingMocks.NodesCoordinatorMock{ ComputeValidatorsGroupCalled: func(randomness []byte, round uint64, shardId uint32, epoch uint32) (validators []nodesCoordinator.Validator, err error) { v, _ := nodesCoordinator.NewValidator(pkAddr, 1, defaultChancesSelection) return []nodesCoordinator.Validator{v, v, v, v, v}, nil @@ -582,9 +582,9 @@ func TestHeaderSigVerifier_VerifySignatureNotEnoughSigsShouldErrWhenFallbackThre }, } - args.NodesCoordinator = nodesCoordinator + args.NodesCoordinator = nc args.FallbackHeaderValidator = fallbackHeaderValidator - args.MultiSigVerifier = multiSigVerifier + args.MultiSigContainer = cryptoMocks.NewMultiSignerContainerMock(multiSigVerifier) hdrSigVerifier, _ := NewHeaderSigVerifier(args) header := &dataBlock.MetaBlock{ @@ -602,7 +602,7 @@ func TestHeaderSigVerifier_VerifySignatureOkWhenFallbackThresholdCouldBeApplied( wasCalled := false args := createHeaderSigVerifierArgs() pkAddr := []byte("aaa00000000000000000000000000000") - nodesCoordinator := &shardingMocks.NodesCoordinatorMock{ + nc := &shardingMocks.NodesCoordinatorMock{ ComputeValidatorsGroupCalled: func(randomness []byte, round uint64, shardId uint32, epoch uint32) (validators []nodesCoordinator.Validator, err error) { v, _ := nodesCoordinator.NewValidator(pkAddr, 1, defaultChancesSelection) return []nodesCoordinator.Validator{v, v, v, v, v}, nil @@ -623,9 +623,9 @@ func TestHeaderSigVerifier_VerifySignatureOkWhenFallbackThresholdCouldBeApplied( }, } - args.NodesCoordinator = nodesCoordinator + args.NodesCoordinator = nc args.FallbackHeaderValidator = fallbackHeaderValidator - args.MultiSigVerifier = multiSigVerifier + args.MultiSigContainer = cryptoMocks.NewMultiSignerContainerMock(multiSigVerifier) hdrSigVerifier, _ := NewHeaderSigVerifier(args) header := &dataBlock.MetaBlock{ diff --git a/process/interface.go b/process/interface.go index cb348a13a71..4e65b4b13d2 100644 --- a/process/interface.go +++ b/process/interface.go @@ -19,6 +19,7 @@ import ( "github.com/ElrondNetwork/elrond-go-core/marshal" "github.com/ElrondNetwork/elrond-go-crypto" "github.com/ElrondNetwork/elrond-go/common" + cryptoCommon "github.com/ElrondNetwork/elrond-go/common/crypto" "github.com/ElrondNetwork/elrond-go/epochStart" "github.com/ElrondNetwork/elrond-go/p2p" "github.com/ElrondNetwork/elrond-go/process/block/bootstrapStorage" @@ -1140,12 +1141,6 @@ type CoreComponentsHolder interface { IsInterfaceNil() bool } -// MultiSignerContainer defines the container for different versioned multiSigner instances -type MultiSignerContainer interface { - GetMultiSigner(epoch uint32) (crypto.MultiSigner, error) - IsInterfaceNil() bool -} - // CryptoComponentsHolder holds the crypto components needed by the interceptors type CryptoComponentsHolder interface { TxSignKeyGen() crypto.KeyGenerator @@ -1153,7 +1148,8 @@ type CryptoComponentsHolder interface { TxSingleSigner() crypto.SingleSigner BlockSigner() crypto.SingleSigner GetMultiSigner(epoch uint32) (crypto.MultiSigner, error) - SetMultiSignerContainer(ms MultiSignerContainer) error + MultiSignerContainer() cryptoCommon.MultiSignerContainer + SetMultiSignerContainer(ms cryptoCommon.MultiSignerContainer) error PeerSignatureHandler() crypto.PeerSignatureHandler PublicKey() crypto.PublicKey Clone() interface{} diff --git a/process/mock/cryptoComponentsMock.go b/process/mock/cryptoComponentsMock.go index 477305cd4be..60bd0918dca 100644 --- a/process/mock/cryptoComponentsMock.go +++ b/process/mock/cryptoComponentsMock.go @@ -5,14 +5,14 @@ import ( "sync" "github.com/ElrondNetwork/elrond-go-crypto" - "github.com/ElrondNetwork/elrond-go/process" + cryptoCommon "github.com/ElrondNetwork/elrond-go/common/crypto" ) // CryptoComponentsMock - type CryptoComponentsMock struct { BlockSig crypto.SingleSigner TxSig crypto.SingleSigner - MultiSigContainer process.MultiSignerContainer + MultiSigContainer cryptoCommon.MultiSignerContainer PeerSignHandler crypto.PeerSignatureHandler BlKeyGen crypto.KeyGenerator TxKeyGen crypto.KeyGenerator @@ -30,23 +30,35 @@ func (ccm *CryptoComponentsMock) TxSingleSigner() crypto.SingleSigner { return ccm.TxSig } -// SetMultiSignerContainer - -func (ccm *CryptoComponentsMock) SetMultiSignerContainer(multiSignerContainer process.MultiSignerContainer) error { - ccm.mutMultiSig.Lock() - ccm.MultiSigContainer = multiSignerContainer - ccm.mutMultiSig.Unlock() - return nil -} - // GetMultiSigner - func (ccm *CryptoComponentsMock) GetMultiSigner(epoch uint32) (crypto.MultiSigner, error) { + ccm.mutMultiSig.RLock() + defer ccm.mutMultiSig.RUnlock() + if ccm.MultiSigContainer == nil { - return nil, errors.New("nil multi signer") + return nil, errors.New("multisigner container is nil") } return ccm.MultiSigContainer.GetMultiSigner(epoch) } +// MultiSignerContainer - +func (ccm *CryptoComponentsMock) MultiSignerContainer() cryptoCommon.MultiSignerContainer { + ccm.mutMultiSig.RLock() + defer ccm.mutMultiSig.RUnlock() + + return ccm.MultiSigContainer +} + +// SetMultiSignerContainer - +func (ccm *CryptoComponentsMock) SetMultiSignerContainer(msc cryptoCommon.MultiSignerContainer) error { + ccm.mutMultiSig.Lock() + defer ccm.mutMultiSig.Unlock() + + ccm.MultiSigContainer = msc + return nil +} + // PeerSignatureHandler returns the peer signature handler func (ccm *CryptoComponentsMock) PeerSignatureHandler() crypto.PeerSignatureHandler { ccm.mutMultiSig.RLock() From 7116ec645b66bed20102b5acec8d8c5205ffdee3 Mon Sep 17 00:00:00 2001 From: AdoAdoAdo Date: Fri, 22 Jul 2022 13:18:16 +0300 Subject: [PATCH 03/10] integrate refactored stateless multisigner --- consensus/mock/mockTestInitializer.go | 10 +- consensus/spos/bls/export_test.go | 4 +- consensus/spos/bls/subroundEndRound.go | 16 +- consensus/spos/bls/subroundSignature.go | 32 ++-- consensus/spos/bls/subroundStartRound.go | 19 +-- consensus/spos/consensusCoreValidator_test.go | 2 +- consensus/spos/subround_test.go | 2 +- consensus/spos/worker.go | 5 +- .../bootstrap/disabled/disabledMultiSigner.go | 44 +----- errors/errors.go | 18 +++ factory/crypto/cryptoComponents.go | 32 +--- factory/crypto/cryptoComponents_test.go | 62 +------- factory/crypto/export_test.go | 10 +- factory/crypto/multiSignerContainer.go | 36 ++++- factory/mock/components/components.go | 3 + factory/mock/components/default.go | 2 +- factory/peerSignatureHandler/export_test.go | 4 +- .../peerSignatureHandler.go | 13 +- .../peerSignatureHandler_test.go | 13 +- go.mod | 2 +- go.sum | 4 +- integrationTests/consensus/testInitializer.go | 7 +- .../multiShard/hardFork/hardFork_test.go | 3 +- integrationTests/testProcessorNode.go | 13 +- .../testProcessorNodeWithCoordinator.go | 22 +-- .../testProcessorNodeWithMultisigner.go | 31 ++-- node/nodeTesting_test.go | 24 +-- p2p/libp2p/p2pSigner.go | 2 +- p2p/libp2p/p2pSigner_test.go | 2 +- .../shardInterceptorsContainerFactory_test.go | 2 +- process/headerCheck/errors.go | 6 + process/headerCheck/headerSignatureVerify.go | 52 +++++-- .../headerCheck/headerSignatureVerify_test.go | 75 ++++------ .../interceptedMetaHeaderDataFactory_test.go | 2 +- testscommon/cryptoMocks/multisignerMock.go | 140 +++--------------- testscommon/cryptoMocks/multisignerStub.go | 112 -------------- 36 files changed, 280 insertions(+), 546 deletions(-) delete mode 100644 testscommon/cryptoMocks/multisignerStub.go diff --git a/consensus/mock/mockTestInitializer.go b/consensus/mock/mockTestInitializer.go index 0757191fe0c..306398bfdf3 100644 --- a/consensus/mock/mockTestInitializer.go +++ b/consensus/mock/mockTestInitializer.go @@ -98,17 +98,17 @@ func InitBlockProcessorHeaderV2Mock() *BlockProcessorMock { // InitMultiSignerMock - func InitMultiSignerMock() *cryptoMocks.MultisignerMock { - multiSigner := cryptoMocks.NewMultiSigner(21) - multiSigner.VerifySignatureShareCalled = func(index uint16, sig []byte, msg []byte, bitmap []byte) error { + multiSigner := cryptoMocks.NewMultiSigner() + multiSigner.VerifySignatureShareCalled = func(publicKey []byte, message []byte, sig []byte) error { return nil } - multiSigner.VerifyCalled = func(msg []byte, bitmap []byte) error { + multiSigner.VerifyAggregatedSigCalled = func(pubKeysSigners [][]byte, message []byte, aggSig []byte) error { return nil } - multiSigner.AggregateSigsCalled = func(bitmap []byte) ([]byte, error) { + multiSigner.AggregateSigsCalled = func(pubKeysSigners [][]byte, signatures [][]byte) ([]byte, error) { return []byte("aggregatedSig"), nil } - multiSigner.CreateSignatureShareCalled = func(msg []byte, bitmap []byte) ([]byte, error) { + multiSigner.CreateSignatureShareCalled = func(privateKeyBytes []byte, message []byte) ([]byte, error) { return []byte("partialSign"), nil } return multiSigner diff --git a/consensus/spos/bls/export_test.go b/consensus/spos/bls/export_test.go index ea97a936bee..a17808324e4 100644 --- a/consensus/spos/bls/export_test.go +++ b/consensus/spos/bls/export_test.go @@ -8,7 +8,7 @@ import ( "github.com/ElrondNetwork/elrond-go-core/data" "github.com/ElrondNetwork/elrond-go-core/hashing" "github.com/ElrondNetwork/elrond-go-core/marshal" - crypto "github.com/ElrondNetwork/elrond-go-crypto" + cryptoCommon "github.com/ElrondNetwork/elrond-go/common/crypto" "github.com/ElrondNetwork/elrond-go/consensus" "github.com/ElrondNetwork/elrond-go/consensus/spos" "github.com/ElrondNetwork/elrond-go/ntp" @@ -61,7 +61,7 @@ func (fct *factory) Marshalizer() marshal.Marshalizer { } // MultiSigner gets the multi signer object -func (fct *factory) MultiSigner() crypto.MultiSigner { +func (fct *factory) MultiSignerContainer() cryptoCommon.MultiSignerContainer { return fct.consensusCore.MultiSignerContainer() } diff --git a/consensus/spos/bls/subroundEndRound.go b/consensus/spos/bls/subroundEndRound.go index 0826c4afef5..7f0e0feeefc 100644 --- a/consensus/spos/bls/subroundEndRound.go +++ b/consensus/spos/bls/subroundEndRound.go @@ -182,6 +182,11 @@ func (sr *subroundEndRound) doEndRoundJob(_ context.Context) bool { return sr.doEndRoundJobByLeader() } +// TODO: this method should return the signers pubKeys and their signatures +func (sr *subroundEndRound) getSigningData() (pubKeys [][]byte, sigShares [][]byte) { + return nil, nil +} + func (sr *subroundEndRound) doEndRoundJobByLeader() bool { bitmap := sr.GenerateBitmap(SrSignature) err := sr.checkSignaturesValidity(bitmap) @@ -190,8 +195,17 @@ func (sr *subroundEndRound) doEndRoundJobByLeader() bool { return false } + multiSigner, err := sr.MultiSignerContainer().GetMultiSigner(sr.Header.GetEpoch()) + if err != nil { + log.Error("doEndRoundJobByLeader.GetMultiSigner", "error", err.Error()) + return false + } + + // TODO: get the signatures from consensus state + pubKeysSigners, sigShares := sr.getSigningData() + // Aggregate sig and add it to the block - sig, err := sr.MultiSignerContainer().AggregateSigs(bitmap) + sig, err := multiSigner.AggregateSigs(pubKeysSigners, sigShares) if err != nil { log.Debug("doEndRoundJobByLeader.AggregateSigs", "error", err.Error()) return false diff --git a/consensus/spos/bls/subroundSignature.go b/consensus/spos/bls/subroundSignature.go index cd577be6623..c2ffdc90913 100644 --- a/consensus/spos/bls/subroundSignature.go +++ b/consensus/spos/bls/subroundSignature.go @@ -69,7 +69,15 @@ func (sr *subroundSignature) doSignatureJob(_ context.Context) bool { return false } - signatureShare, err := sr.MultiSignerContainer().CreateSignatureShare(sr.GetData(), nil) + multiSigner, err := sr.MultiSignerContainer().GetMultiSigner(sr.Header.GetEpoch()) + if err != nil { + log.Error("doSignatureJob.GetMultiSigner", "error", err.Error()) + return false + } + + // TODO: keep private key as byte array in consensus + privateKey, _ := sr.PrivateKey().ToByteArray() + signatureShare, err := multiSigner.CreateSignatureShare(privateKey, sr.GetData()) if err != nil { log.Debug("doSignatureJob.CreateSignatureShare", "error", err.Error()) return false @@ -160,25 +168,31 @@ func (sr *subroundSignature) receivedSignature(_ context.Context, cnsDta *consen return false } - currentMultiSigner := sr.MultiSignerContainer() - err = currentMultiSigner.VerifySignatureShare(uint16(index), cnsDta.SignatureShare, sr.GetData(), nil) + currentMultiSigner, err := sr.MultiSignerContainer().GetMultiSigner(sr.Header.GetEpoch()) if err != nil { - log.Debug("receivedSignature.VerifySignatureShare", - "node", pkForLogs, - "index", index, - "error", err.Error()) + log.Error("receivedSignature.GetMultiSigner", "error", err.Error()) return false } - err = currentMultiSigner.StoreSignatureShare(uint16(index), cnsDta.SignatureShare) + err = currentMultiSigner.VerifySignatureShare([]byte(node), sr.GetData(), cnsDta.SignatureShare) if err != nil { - log.Debug("receivedSignature.StoreSignatureShare", + log.Debug("receivedSignature.VerifySignatureShare", "node", pkForLogs, "index", index, "error", err.Error()) return false } + // TODO: store here the signature in consensus state + //err = currentMultiSigner.StoreSignatureShare(uint16(index), cnsDta.SignatureShare) + //if err != nil { + // log.Debug("receivedSignature.StoreSignatureShare", + // "node", pkForLogs, + // "index", index, + // "error", err.Error()) + // return false + //} + err = sr.SetJobDone(node, sr.Current(), true) if err != nil { log.Debug("receivedSignature.SetJobDone", diff --git a/consensus/spos/bls/subroundStartRound.go b/consensus/spos/bls/subroundStartRound.go index cae9649d3bf..f04e62df6d0 100644 --- a/consensus/spos/bls/subroundStartRound.go +++ b/consensus/spos/bls/subroundStartRound.go @@ -170,7 +170,7 @@ func (sr *subroundStartRound) initCurrentRound() bool { sr.indexRoundIfNeeded(pubKeys) - selfIndex, err := sr.SelfConsensusGroupIndex() + _, err = sr.SelfConsensusGroupIndex() if err != nil { log.Debug("not in consensus group") sr.AppStatusHandler().SetStringValue(common.MetricConsensusState, "not in consensus group") @@ -181,14 +181,15 @@ func (sr *subroundStartRound) initCurrentRound() bool { sr.AppStatusHandler().SetStringValue(common.MetricConsensusState, "participant") } - err = sr.MultiSignerContainer().Reset(pubKeys, uint16(selfIndex)) - if err != nil { - log.Debug("initCurrentRound.Reset", "error", err.Error()) - - sr.RoundCanceled = true - - return false - } + // TODO: reset here signatures/signers data in consensus + //err = sr.MultiSignerContainer().Reset(pubKeys, uint16(selfIndex)) + //if err != nil { + // log.Debug("initCurrentRound.Reset", "error", err.Error()) + // + // sr.RoundCanceled = true + // + // return false + //} startTime := sr.RoundTimeStamp maxTime := sr.RoundHandler().TimeDuration() * time.Duration(sr.processingThresholdPercentage) / 100 diff --git a/consensus/spos/consensusCoreValidator_test.go b/consensus/spos/consensusCoreValidator_test.go index b750b1af313..f898fc2a3db 100644 --- a/consensus/spos/consensusCoreValidator_test.go +++ b/consensus/spos/consensusCoreValidator_test.go @@ -19,7 +19,7 @@ func initConsensusDataContainer() *ConsensusCore { chronologyHandlerMock := mock.InitChronologyHandlerMock() blsPrivateKeyMock := &mock.PrivateKeyMock{} blsSingleSignerMock := &mock.SingleSignerMock{} - multiSignerMock := cryptoMocks.NewMultiSigner(21) + multiSignerMock := cryptoMocks.NewMultiSigner() hasherMock := &hashingMocks.HasherMock{} marshalizerMock := mock.MarshalizerMock{} roundHandlerMock := &mock.RoundHandlerMock{} diff --git a/consensus/spos/subround_test.go b/consensus/spos/subround_test.go index f3b78f8ae23..33489efc82a 100644 --- a/consensus/spos/subround_test.go +++ b/consensus/spos/subround_test.go @@ -363,7 +363,7 @@ func TestSubround_NilContainerMultisignerShouldFail(t *testing.T) { consensusState := initConsensusState() ch := make(chan bool, 1) container := mock.InitConsensusCore() - container.SetMultiSigner(nil) + container.SetMultiSignerContainer(nil) sr, err := spos.NewSubround( -1, diff --git a/consensus/spos/worker.go b/consensus/spos/worker.go index 3c3cf391822..62d687d794a 100644 --- a/consensus/spos/worker.go +++ b/consensus/spos/worker.go @@ -19,6 +19,7 @@ import ( crypto "github.com/ElrondNetwork/elrond-go-crypto" "github.com/ElrondNetwork/elrond-go/common" "github.com/ElrondNetwork/elrond-go/consensus" + errorsErd "github.com/ElrondNetwork/elrond-go/errors" "github.com/ElrondNetwork/elrond-go/ntp" "github.com/ElrondNetwork/elrond-go/p2p" "github.com/ElrondNetwork/elrond-go/process" @@ -411,8 +412,8 @@ func (wrk *Worker) shouldBlacklistPeer(err error) bool { errors.Is(err, ErrMessageForPastRound) || errors.Is(err, ErrMessageForFutureRound) || errors.Is(err, ErrNodeIsNotInEligibleList) || - errors.Is(err, crypto.ErrPIDMismatch) || - errors.Is(err, crypto.ErrSignatureMismatch) || + errors.Is(err, errorsErd.ErrPIDMismatch) || + errors.Is(err, errorsErd.ErrSignatureMismatch) || errors.Is(err, nodesCoordinator.ErrEpochNodesConfigDoesNotExist) || errors.Is(err, ErrMessageTypeLimitReached) { return false diff --git a/epochStart/bootstrap/disabled/disabledMultiSigner.go b/epochStart/bootstrap/disabled/disabledMultiSigner.go index 46c5cff28ff..dd7c5e4d7b6 100644 --- a/epochStart/bootstrap/disabled/disabledMultiSigner.go +++ b/epochStart/bootstrap/disabled/disabledMultiSigner.go @@ -1,9 +1,5 @@ package disabled -import ( - "github.com/ElrondNetwork/elrond-go-crypto" -) - type multiSigner struct { } @@ -12,54 +8,24 @@ func NewMultiSigner() *multiSigner { return &multiSigner{} } -// Create returns a nil instance and a nil error -func (m *multiSigner) Create(_ []string, _ uint16) (crypto.MultiSigner, error) { - return nil, nil -} - -// SetAggregatedSig returns nil -func (m *multiSigner) SetAggregatedSig([]byte) error { - return nil -} - -// Verify returns nil -func (m *multiSigner) Verify(_ []byte, _ []byte) error { - return nil -} - -// Reset returns nil and does nothing -func (m *multiSigner) Reset(_ []string, _ uint16) error { - return nil -} - // CreateSignatureShare returns nil byte slice and nil error func (m *multiSigner) CreateSignatureShare(_ []byte, _ []byte) ([]byte, error) { return nil, nil } -// StoreSignatureShare returns nil -func (m *multiSigner) StoreSignatureShare(_ uint16, _ []byte) error { - return nil -} - -// SignatureShare returns nil byte slice and a nil error -func (m *multiSigner) SignatureShare(_ uint16) ([]byte, error) { - return nil, nil -} - // VerifySignatureShare returns nil -func (m *multiSigner) VerifySignatureShare(_ uint16, _ []byte, _ []byte, _ []byte) error { +func (m *multiSigner) VerifySignatureShare(_ []byte, _ []byte, _ []byte) error { return nil } // AggregateSigs returns nil byte slice and nil error -func (m *multiSigner) AggregateSigs(_ []byte) ([]byte, error) { +func (m *multiSigner) AggregateSigs(_ [][]byte, _ [][]byte) ([]byte, error) { return nil, nil } -// CreateAndAddSignatureShareForKey will return an empty slice and a nil error -func (m *multiSigner) CreateAndAddSignatureShareForKey(_ []byte, _ crypto.PrivateKey, _ []byte) ([]byte, error) { - return make([]byte, 0), nil +// VerifyAggregatedSig returns nil +func (m *multiSigner) VerifyAggregatedSig(_ [][]byte, _ []byte, _ []byte) error { + return nil } // IsInterfaceNil returns true if there is no value under the interface diff --git a/errors/errors.go b/errors/errors.go index 7c9e2344d2c..d21811d4ca0 100644 --- a/errors/errors.go +++ b/errors/errors.go @@ -487,3 +487,21 @@ var ErrMissingMultiSignerConfig = errors.New("multisigner configuration missing" // ErrNilMultiSignerContainer signals that the multisigner container is nil var ErrNilMultiSignerContainer = errors.New("multisigner container is nil") + +// ErrNilCacher signals that a nil cacher has been provided +var ErrNilCacher = errors.New("nil cacher") + +// ErrNilSingleSigner is raised when a valid singleSigner is expected but nil used +var ErrNilSingleSigner = errors.New("singleSigner is nil") + +// ErrPIDMismatch signals that the pid from the message is different from the cached pid associated to a certain pk +var ErrPIDMismatch = errors.New("pid mismatch") + +// ErrSignatureMismatch signals that the signature from the message is different from the cached signature associated to a certain pk +var ErrSignatureMismatch = errors.New("signature mismatch") + +// ErrInvalidPID signals that given PID is invalid +var ErrInvalidPID = errors.New("invalid PID") + +// ErrInvalidSignature signals that the given signature is invalid +var ErrInvalidSignature = errors.New("invalid signature") diff --git a/factory/crypto/cryptoComponents.go b/factory/crypto/cryptoComponents.go index 2cb9d1f7d41..b82222c7b2b 100644 --- a/factory/crypto/cryptoComponents.go +++ b/factory/crypto/cryptoComponents.go @@ -6,9 +6,6 @@ import ( "fmt" "github.com/ElrondNetwork/elrond-go-core/core/check" - "github.com/ElrondNetwork/elrond-go-core/hashing" - "github.com/ElrondNetwork/elrond-go-core/hashing/blake2b" - "github.com/ElrondNetwork/elrond-go-core/hashing/sha256" "github.com/ElrondNetwork/elrond-go-crypto" "github.com/ElrondNetwork/elrond-go-crypto/signing" disabledCrypto "github.com/ElrondNetwork/elrond-go-crypto/signing/disabled" @@ -17,7 +14,6 @@ import ( "github.com/ElrondNetwork/elrond-go-crypto/signing/ed25519/singlesig" "github.com/ElrondNetwork/elrond-go-crypto/signing/mcl" mclSig "github.com/ElrondNetwork/elrond-go-crypto/signing/mcl/singlesig" - "github.com/ElrondNetwork/elrond-go-crypto/signing/multisig" logger "github.com/ElrondNetwork/elrond-go-logger" cryptoCommon "github.com/ElrondNetwork/elrond-go/common/crypto" "github.com/ElrondNetwork/elrond-go/config" @@ -136,12 +132,7 @@ func (ccf *cryptoComponentsFactory) Create() (*cryptoComponents, error) { return nil, err } - multisigHasher, err := ccf.getMultiSigHasherFromConfig() - if err != nil { - return nil, err - } - - multiSigner, err := ccf.createMultiSignerContainer(multisigHasher, cp, blockSignKeyGen, ccf.importModeNoSigCheck) + multiSigner, err := ccf.createMultiSignerContainer(cp, blockSignKeyGen, ccf.importModeNoSigCheck) if err != nil { return nil, err } @@ -201,33 +192,14 @@ func (ccf *cryptoComponentsFactory) createSingleSigner(importModeNoSigCheck bool } } -func (ccf *cryptoComponentsFactory) getMultiSigHasherFromConfig() (hashing.Hasher, error) { - if ccf.consensusType == consensus.BlsConsensusType && ccf.config.MultisigHasher.Type != "blake2b" { - return nil, errors.ErrMultiSigHasherMissmatch - } - - switch ccf.config.MultisigHasher.Type { - case "sha256": - return sha256.NewSha256(), nil - case "blake2b": - if ccf.consensusType == consensus.BlsConsensusType { - return blake2b.NewBlake2bWithSize(multisig.BlsHashSize) - } - return blake2b.NewBlake2b(), nil - } - - return nil, errors.ErrMissingMultiHasherConfig -} - func (ccf *cryptoComponentsFactory) createMultiSignerContainer( - hasher hashing.Hasher, cp *cryptoParams, blSignKeyGen crypto.KeyGenerator, importModeNoSigCheck bool, ) (cryptoCommon.MultiSignerContainer, error) { args := MultiSigArgs{ - hasher: hasher, + multiSigHasherType: ccf.config.MultisigHasher.Type, cryptoParams: cp, blSignKeyGen: blSignKeyGen, consensusType: ccf.consensusType, diff --git a/factory/crypto/cryptoComponents_test.go b/factory/crypto/cryptoComponents_test.go index bde7cf0f0f4..3c948a20d12 100644 --- a/factory/crypto/cryptoComponents_test.go +++ b/factory/crypto/cryptoComponents_test.go @@ -12,7 +12,6 @@ import ( cryptoComp "github.com/ElrondNetwork/elrond-go/factory/crypto" "github.com/ElrondNetwork/elrond-go/factory/mock" componentsMock "github.com/ElrondNetwork/elrond-go/factory/mock/components" - "github.com/ElrondNetwork/elrond-go/testscommon/hashingMocks" "github.com/stretchr/testify/require" ) @@ -206,62 +205,6 @@ func TestCryptoComponentsFactory_CreateSingleSignerOK(t *testing.T) { require.NotNil(t, singleSigner) } -func TestCryptoComponentsFactory_GetMultiSigHasherFromConfigInvalidHasherShouldErr(t *testing.T) { - t.Parallel() - if testing.Short() { - t.Skip("this is not a short test") - } - - coreComponents := componentsMock.GetCoreComponents() - args := componentsMock.GetCryptoArgs(coreComponents) - args.Config.Consensus.Type = "" - args.Config.MultisigHasher.Type = "" - ccf, err := cryptoComp.NewCryptoComponentsFactory(args) - require.NotNil(t, ccf) - require.Nil(t, err) - - multiSigHasher, err := ccf.GetMultiSigHasherFromConfig() - require.Nil(t, multiSigHasher) - require.Equal(t, errErd.ErrMissingMultiHasherConfig, err) -} - -func TestCryptoComponentsFactory_GetMultiSigHasherFromConfigMismatchConsensusTypeMultiSigHasher(t *testing.T) { - t.Parallel() - if testing.Short() { - t.Skip("this is not a short test") - } - - coreComponents := componentsMock.GetCoreComponents() - args := componentsMock.GetCryptoArgs(coreComponents) - args.Config.MultisigHasher.Type = "sha256" - ccf, err := cryptoComp.NewCryptoComponentsFactory(args) - require.NotNil(t, ccf) - require.Nil(t, err) - - multiSigHasher, err := ccf.GetMultiSigHasherFromConfig() - require.Nil(t, multiSigHasher) - require.Equal(t, errErd.ErrMultiSigHasherMissmatch, err) -} - -func TestCryptoComponentsFactory_GetMultiSigHasherFromConfigOK(t *testing.T) { - t.Parallel() - if testing.Short() { - t.Skip("this is not a short test") - } - - coreComponents := componentsMock.GetCoreComponents() - args := componentsMock.GetCryptoArgs(coreComponents) - args.Config.Consensus.Type = "bls" - args.Config.MultisigHasher.Type = "blake2b" - ccf, err := cryptoComp.NewCryptoComponentsFactory(args) - require.NotNil(t, ccf) - require.Nil(t, err) - - multiSigHasher, err := ccf.GetMultiSigHasherFromConfig() - require.Nil(t, err) - require.NotNil(t, multiSigHasher) -} - func TestCryptoComponentsFactory_CreateMultiSignerInvalidConsensusTypeShouldErr(t *testing.T) { t.Parallel() if testing.Short() { @@ -276,7 +219,7 @@ func TestCryptoComponentsFactory_CreateMultiSignerInvalidConsensusTypeShouldErr( require.Nil(t, err) cp := ccf.CreateDummyCryptoParams() - multiSigner, err := ccf.CreateMultiSignerContainer(&hashingMocks.HasherMock{}, cp, &mock.KeyGenMock{}, false) + multiSigner, err := ccf.CreateMultiSignerContainer(cp, &mock.KeyGenMock{}, false) require.Nil(t, multiSigner) require.Equal(t, errErd.ErrInvalidConsensusConfig, err) } @@ -296,9 +239,8 @@ func TestCryptoComponentsFactory_CreateMultiSignerOK(t *testing.T) { suite, _ := ccf.GetSuite() blockSignKeyGen := signing.NewKeyGenerator(suite) cp, _ := ccf.CreateCryptoParams(blockSignKeyGen) - multisigHasher, _ := ccf.GetMultiSigHasherFromConfig() - multiSigner, err := ccf.CreateMultiSignerContainer(multisigHasher, cp, blockSignKeyGen, false) + multiSigner, err := ccf.CreateMultiSignerContainer(cp, blockSignKeyGen, false) require.Nil(t, err) require.NotNil(t, multiSigner) } diff --git a/factory/crypto/export_test.go b/factory/crypto/export_test.go index 402769d3f13..6efc1e53c45 100644 --- a/factory/crypto/export_test.go +++ b/factory/crypto/export_test.go @@ -17,8 +17,8 @@ func (ccf *cryptoComponentsFactory) CreateSingleSigner(importModeNoSigCheck bool } // GetMultiSigHasherFromConfig - -func (ccf *cryptoComponentsFactory) GetMultiSigHasherFromConfig() (hashing.Hasher, error) { - return ccf.getMultiSigHasherFromConfig() +func GetMultiSigHasherFromConfig(args MultiSigArgs) (hashing.Hasher, error) { + return getMultiSigHasherFromConfig(args) } // CreateDummyCryptoParams @@ -33,9 +33,11 @@ func (ccf *cryptoComponentsFactory) CreateCryptoParams(blockSignKeyGen crypto.Ke // CreateMultiSignerContainer - func (ccf *cryptoComponentsFactory) CreateMultiSignerContainer( - h hashing.Hasher, cp *cryptoParams, blSignKeyGen crypto.KeyGenerator, importModeNoSigCheck bool, + cp *cryptoParams, + blSignKeyGen crypto.KeyGenerator, + importModeNoSigCheck bool, ) (cryptoCommon.MultiSignerContainer, error) { - return ccf.createMultiSignerContainer(h, cp, blSignKeyGen, importModeNoSigCheck) + return ccf.createMultiSignerContainer(cp, blSignKeyGen, importModeNoSigCheck) } // GetSuite - diff --git a/factory/crypto/multiSignerContainer.go b/factory/crypto/multiSignerContainer.go index afcd42b5f50..d4b44a05f2d 100644 --- a/factory/crypto/multiSignerContainer.go +++ b/factory/crypto/multiSignerContainer.go @@ -6,6 +6,8 @@ import ( "github.com/ElrondNetwork/elrond-go-core/core/check" "github.com/ElrondNetwork/elrond-go-core/hashing" + "github.com/ElrondNetwork/elrond-go-core/hashing/blake2b" + "github.com/ElrondNetwork/elrond-go-core/hashing/sha256" crypto "github.com/ElrondNetwork/elrond-go-crypto" disabledMultiSig "github.com/ElrondNetwork/elrond-go-crypto/signing/disabled/multisig" mclMultiSig "github.com/ElrondNetwork/elrond-go-crypto/signing/mcl/multisig" @@ -16,8 +18,8 @@ import ( ) const ( - blsNonKOSK = "non-KOSK" - blsKOSK = "KOSK" + blsNoKOSK = "no-KOSK" + blsKOSK = "KOSK" ) type epochMultiSigner struct { @@ -32,7 +34,7 @@ type container struct { // MultiSigArgs holds the arguments for creating the multiSignerContainer container type MultiSigArgs struct { - hasher hashing.Hasher + multiSigHasherType string cryptoParams *cryptoParams blSignKeyGen crypto.KeyGenerator consensusType string @@ -95,11 +97,15 @@ func createMultiSigner(multiSigType string, args MultiSigArgs) (crypto.MultiSign switch args.consensusType { case consensus.BlsConsensusType: - blsSigner, err := createLowLevelSigner(multiSigType, args.hasher) + hasher, err := getMultiSigHasherFromConfig(args) if err != nil { return nil, err } - return multisig.NewBLSMultisig(blsSigner, []string{string(args.cryptoParams.publicKeyBytes)}, args.cryptoParams.privateKey, args.blSignKeyGen, uint16(0)) + blsSigner, err := createLowLevelSigner(multiSigType, hasher) + if err != nil { + return nil, err + } + return multisig.NewBLSMultisig(blsSigner, args.blSignKeyGen) case disabledSigChecking: log.Warn("using disabled multi signer") return &disabledMultiSig.DisabledMultiSig{}, nil @@ -114,7 +120,7 @@ func createLowLevelSigner(multiSigType string, hasher hashing.Hasher) (crypto.Lo } switch multiSigType { - case blsNonKOSK: + case blsNoKOSK: return &mclMultiSig.BlsMultiSigner{Hasher: hasher}, nil case blsKOSK: return &mclMultiSig.BlsMultiSignerKOSK{}, nil @@ -123,6 +129,24 @@ func createLowLevelSigner(multiSigType string, hasher hashing.Hasher) (crypto.Lo } } +func getMultiSigHasherFromConfig(args MultiSigArgs) (hashing.Hasher, error) { + if args.consensusType == consensus.BlsConsensusType && args.multiSigHasherType != "blake2b" { + return nil, errors.ErrMultiSigHasherMissmatch + } + + switch args.multiSigHasherType { + case "sha256": + return sha256.NewSha256(), nil + case "blake2b": + if args.consensusType == consensus.BlsConsensusType { + return blake2b.NewBlake2bWithSize(mclMultiSig.HasherOutputSize) + } + return blake2b.NewBlake2b(), nil + } + + return nil, errors.ErrMissingMultiHasherConfig +} + func sortMultiSignerConfig(multiSignerConfig []config.MultiSignerConfig) []config.MultiSignerConfig { sortedMultiSignerConfig := append([]config.MultiSignerConfig{}, multiSignerConfig...) sort.Slice(sortedMultiSignerConfig, func(i, j int) bool { diff --git a/factory/mock/components/components.go b/factory/mock/components/components.go index 23229f74a8d..464432519e5 100644 --- a/factory/mock/components/components.go +++ b/factory/mock/components/components.go @@ -238,6 +238,9 @@ func GetCryptoArgs(coreComponents factory.CoreComponentsHolder) cryptoComp.Crypt KeyLoader: &mock.KeyLoaderStub{ LoadKeyCalled: DummyLoadSkPkFromPemFile([]byte(DummySk), DummyPk, nil), }, + EnableEpochs: config.EnableEpochs{ + BLSMultiSignerEnableEpoch: []config.MultiSignerConfig{{EnableEpoch: 0, Type: "no-KOSK"}}, + }, } return args diff --git a/factory/mock/components/default.go b/factory/mock/components/default.go index b5b8bd1bd9e..e4fe5d55e63 100644 --- a/factory/mock/components/default.go +++ b/factory/mock/components/default.go @@ -60,7 +60,7 @@ func GetDefaultCryptoComponents() *mock.CryptoComponentsMock { PubKeyBytes: []byte("pubKey"), BlockSig: &mock.SinglesignMock{}, TxSig: &mock.SinglesignMock{}, - MultiSigContainer: &cryptoMocks.MultisignerStub{}, + MultiSigContainer: cryptoMocks.NewMultiSignerContainerMock(&cryptoMocks.MultisignerMock{}), PeerSignHandler: &mock.PeerSignatureHandler{}, BlKeyGen: &mock.KeyGenMock{}, TxKeyGen: &mock.KeyGenMock{}, diff --git a/factory/peerSignatureHandler/export_test.go b/factory/peerSignatureHandler/export_test.go index 89ecb48ff94..6132b794ed1 100644 --- a/factory/peerSignatureHandler/export_test.go +++ b/factory/peerSignatureHandler/export_test.go @@ -2,13 +2,13 @@ package peerSignatureHandler import ( "github.com/ElrondNetwork/elrond-go-core/core" - "github.com/ElrondNetwork/elrond-go-crypto" + "github.com/ElrondNetwork/elrond-go/errors" ) func (psh *peerSignatureHandler) GetPIDAndSig(entry interface{}) (core.PeerID, []byte, error) { pidSig, ok := entry.(*pidSignature) if !ok { - return "", nil, crypto.ErrWrongTypeAssertion + return "", nil, errors.ErrWrongTypeAssertion } return pidSig.pid, pidSig.signature, nil diff --git a/factory/peerSignatureHandler/peerSignatureHandler.go b/factory/peerSignatureHandler/peerSignatureHandler.go index b169d140720..6fa1f622915 100644 --- a/factory/peerSignatureHandler/peerSignatureHandler.go +++ b/factory/peerSignatureHandler/peerSignatureHandler.go @@ -6,6 +6,7 @@ import ( "github.com/ElrondNetwork/elrond-go-core/core" "github.com/ElrondNetwork/elrond-go-core/core/check" "github.com/ElrondNetwork/elrond-go-crypto" + "github.com/ElrondNetwork/elrond-go/errors" "github.com/ElrondNetwork/elrond-go/storage" ) @@ -29,10 +30,10 @@ func NewPeerSignatureHandler( keygen crypto.KeyGenerator, ) (*peerSignatureHandler, error) { if check.IfNil(pkPIDSignature) { - return nil, crypto.ErrNilCacher + return nil, errors.ErrNilCacher } if check.IfNil(singleSigner) { - return nil, crypto.ErrNilSingleSigner + return nil, errors.ErrNilSingleSigner } if check.IfNil(keygen) { return nil, crypto.ErrNilKeyGenerator @@ -52,10 +53,10 @@ func (psh *peerSignatureHandler) VerifyPeerSignature(pk []byte, pid core.PeerID, return crypto.ErrInvalidPublicKey } if len(pid) == 0 { - return crypto.ErrInvalidPID + return errors.ErrInvalidPID } if len(signature) == 0 { - return crypto.ErrInvalidSignature + return errors.ErrInvalidSignature } senderPubKey, err := psh.keygen.PublicKeyFromByteArray(pk) @@ -77,11 +78,11 @@ func (psh *peerSignatureHandler) VerifyPeerSignature(pk []byte, pid core.PeerID, } if retrievedPID != pid { - return crypto.ErrPIDMismatch + return errors.ErrPIDMismatch } if !bytes.Equal(retrievedSig, signature) { - return crypto.ErrSignatureMismatch + return errors.ErrSignatureMismatch } return nil diff --git a/factory/peerSignatureHandler/peerSignatureHandler_test.go b/factory/peerSignatureHandler/peerSignatureHandler_test.go index b4f47b0dd3f..3ab7717221b 100644 --- a/factory/peerSignatureHandler/peerSignatureHandler_test.go +++ b/factory/peerSignatureHandler/peerSignatureHandler_test.go @@ -7,6 +7,7 @@ import ( "github.com/ElrondNetwork/elrond-go-core/core" "github.com/ElrondNetwork/elrond-go-core/core/check" "github.com/ElrondNetwork/elrond-go-crypto" + errorsErd "github.com/ElrondNetwork/elrond-go/errors" "github.com/ElrondNetwork/elrond-go/factory/peerSignatureHandler" "github.com/ElrondNetwork/elrond-go/testscommon" "github.com/ElrondNetwork/elrond-go/testscommon/cryptoMocks" @@ -23,7 +24,7 @@ func TestNewPeerSignatureHandler_NilCacherShouldErr(t *testing.T) { ) assert.True(t, check.IfNil(peerSigHandler)) - assert.Equal(t, crypto.ErrNilCacher, err) + assert.Equal(t, errorsErd.ErrNilCacher, err) } func TestNewPeerSignatureHandler_NilSingleSignerShouldErr(t *testing.T) { @@ -36,7 +37,7 @@ func TestNewPeerSignatureHandler_NilSingleSignerShouldErr(t *testing.T) { ) assert.True(t, check.IfNil(peerSigHandler)) - assert.Equal(t, crypto.ErrNilSingleSigner, err) + assert.Equal(t, errorsErd.ErrNilSingleSigner, err) } func TestNewPeerSignatureHandler_NilKeyGenShouldErr(t *testing.T) { @@ -88,7 +89,7 @@ func TestPeerSignatureHandler_VerifyPeerSignatureInvalidPID(t *testing.T) { ) err := peerSigHandler.VerifyPeerSignature([]byte("public key"), "", []byte("signature")) - assert.Equal(t, crypto.ErrInvalidPID, err) + assert.Equal(t, errorsErd.ErrInvalidPID, err) } func TestPeerSignatureHandler_VerifyPeerSignatureInvalidSignature(t *testing.T) { @@ -101,7 +102,7 @@ func TestPeerSignatureHandler_VerifyPeerSignatureInvalidSignature(t *testing.T) ) err := peerSigHandler.VerifyPeerSignature([]byte("public key"), "dummy peer", nil) - assert.Equal(t, crypto.ErrInvalidSignature, err) + assert.Equal(t, errorsErd.ErrInvalidSignature, err) } func TestPeerSignatureHandler_VerifyPeerSignatureCantGetPubKeyBytes(t *testing.T) { @@ -303,7 +304,7 @@ func TestPeerSignatureHandler_VerifyPeerSignatureDifferentPid(t *testing.T) { cache.Put(pk, cacheEntry, len(pid)+len(sig)) err := peerSigHandler.VerifyPeerSignature(pk, newPid, sig) - assert.Equal(t, crypto.ErrPIDMismatch, err) + assert.Equal(t, errorsErd.ErrPIDMismatch, err) assert.False(t, verifyCalled) } @@ -343,7 +344,7 @@ func TestPeerSignatureHandler_VerifyPeerSignatureDifferentSig(t *testing.T) { cache.Put(pk, cacheEntry, len(pid)+len(sig)) err := peerSigHandler.VerifyPeerSignature(pk, pid, newSig) - assert.Equal(t, crypto.ErrSignatureMismatch, err) + assert.Equal(t, errorsErd.ErrSignatureMismatch, err) assert.False(t, verifyCalled) } diff --git a/go.mod b/go.mod index 096a428db08..8b3822f11c5 100644 --- a/go.mod +++ b/go.mod @@ -10,7 +10,7 @@ require ( github.com/ElrondNetwork/covalent-indexer-go v1.0.6 github.com/ElrondNetwork/elastic-indexer-go v1.2.34-partial-execution github.com/ElrondNetwork/elrond-go-core v1.1.16-0.20220708085217-ccc0c5ac9076 - github.com/ElrondNetwork/elrond-go-crypto v1.1.0 + github.com/ElrondNetwork/elrond-go-crypto v1.1.1-0.20220721140234-4e1d265e997e github.com/ElrondNetwork/elrond-go-logger v1.0.7 github.com/ElrondNetwork/elrond-vm-common v1.3.13 github.com/ElrondNetwork/go-libp2p-pubsub v0.6.1-rc1 diff --git a/go.sum b/go.sum index 50cf78dedb2..e3bbc911891 100644 --- a/go.sum +++ b/go.sum @@ -64,8 +64,8 @@ github.com/ElrondNetwork/elrond-go-core v1.1.16-0.20220414130405-e3cc29bc7711/go github.com/ElrondNetwork/elrond-go-core v1.1.16-0.20220708085217-ccc0c5ac9076 h1:/tNU9ydW91/rZAFTDXSDhLSPEcBs9w6+g+4NF6uqMeo= github.com/ElrondNetwork/elrond-go-core v1.1.16-0.20220708085217-ccc0c5ac9076/go.mod h1:Yz8JK5sGBctw7+gU8j2mZHbzQ09Ek4XHJ4Uinq1N6nM= github.com/ElrondNetwork/elrond-go-crypto v1.0.0/go.mod h1:DGiR7/j1xv729Xg8SsjYaUzWXL5svMd44REXjWS/gAc= -github.com/ElrondNetwork/elrond-go-crypto v1.1.0 h1:fC4FPl7u45llTf+fkQjsSA30QKVww3be4TZsiKMH94A= -github.com/ElrondNetwork/elrond-go-crypto v1.1.0/go.mod h1:uunsvweBrrhVojL8uiQSaTPsl3YIQ9iBqtYGM6xs4s0= +github.com/ElrondNetwork/elrond-go-crypto v1.1.1-0.20220721140234-4e1d265e997e h1:rCVoKQCCJGTLDFhGJyw+xzahYs/64OBCFVD3zYKOngo= +github.com/ElrondNetwork/elrond-go-crypto v1.1.1-0.20220721140234-4e1d265e997e/go.mod h1:uunsvweBrrhVojL8uiQSaTPsl3YIQ9iBqtYGM6xs4s0= github.com/ElrondNetwork/elrond-go-logger v1.0.4/go.mod h1:e5D+c97lKUfFdAzFX7rrI2Igl/z4Y0RkKYKWyzprTGk= github.com/ElrondNetwork/elrond-go-logger v1.0.5/go.mod h1:cBfgx0ST/CJx8jrxJSC5aiSrvkGzcnF7sK06RD8mFxQ= github.com/ElrondNetwork/elrond-go-logger v1.0.7 h1:Ldl1rVS0RGKc1IsW8jIaGCb6Zwei04gsMvyjL05X6mE= diff --git a/integrationTests/consensus/testInitializer.go b/integrationTests/consensus/testInitializer.go index c9cc3213d11..638ce53ffda 100644 --- a/integrationTests/consensus/testInitializer.go +++ b/integrationTests/consensus/testInitializer.go @@ -252,7 +252,6 @@ func createConsensusOnlyNode( shardCoordinator sharding.Coordinator, nodesCoordinator nodesCoordinator.NodesCoordinator, shardId uint32, - selfId uint32, consensusSize uint32, roundTime uint64, privKey crypto.PrivateKey, @@ -378,8 +377,7 @@ func createConsensusOnlyNode( inPubKeys[shardId] = append(inPubKeys[shardId], string(sPubKey)) } - testMultiSig := cryptoMocks.NewMultiSigner(consensusSize) - _ = testMultiSig.Reset(inPubKeys[shardId], uint16(selfId)) + testMultiSig := cryptoMocks.NewMultiSigner() peerSigCache, _ := storageUnit.NewCache(storageUnit.CacheConfig{Type: storageUnit.LRUCache, Capacity: 1000}) peerSigHandler, _ := peerSignatureHandler.NewPeerSignatureHandler(peerSigCache, singleBlsSigner, testKeyGen) @@ -414,7 +412,7 @@ func createConsensusOnlyNode( cryptoComponents.PubKey = privKey.GeneratePublic() cryptoComponents.BlockSig = singleBlsSigner cryptoComponents.TxSig = singlesigner - cryptoComponents.MultiSigContainer = testMultiSig + cryptoComponents.MultiSigContainer = cryptoMocks.NewMultiSignerContainerMock(testMultiSig) cryptoComponents.BlKeyGen = testKeyGen cryptoComponents.PeerSignHandler = peerSigHandler @@ -535,7 +533,6 @@ func createNodes( shardCoordinator, nodesCoord, testNodeObject.shardId, - uint32(i), uint32(consensusSize), roundTime, kp.sk, diff --git a/integrationTests/multiShard/hardFork/hardFork_test.go b/integrationTests/multiShard/hardFork/hardFork_test.go index d0792de4a1b..66c6eaa82bc 100644 --- a/integrationTests/multiShard/hardFork/hardFork_test.go +++ b/integrationTests/multiShard/hardFork/hardFork_test.go @@ -22,6 +22,7 @@ import ( "github.com/ElrondNetwork/elrond-go/integrationTests/vm/arwen" vmFactory "github.com/ElrondNetwork/elrond-go/process/factory" "github.com/ElrondNetwork/elrond-go/state" + "github.com/ElrondNetwork/elrond-go/testscommon/cryptoMocks" "github.com/ElrondNetwork/elrond-go/testscommon/genesisMocks" "github.com/ElrondNetwork/elrond-go/update/factory" "github.com/ElrondNetwork/elrond-go/vm/systemSmartContracts/defaults" @@ -564,7 +565,7 @@ func createHardForkExporter( cryptoComponents := integrationTests.GetDefaultCryptoComponents() cryptoComponents.BlockSig = node.OwnAccount.BlockSingleSigner cryptoComponents.TxSig = node.OwnAccount.SingleSigner - cryptoComponents.MultiSigContainer = node.MultiSigner + cryptoComponents.MultiSigContainer = cryptoMocks.NewMultiSignerContainerMock(node.MultiSigner) cryptoComponents.BlKeyGen = node.OwnAccount.KeygenBlockSign cryptoComponents.TxKeyGen = node.OwnAccount.KeygenTxSign diff --git a/integrationTests/testProcessorNode.go b/integrationTests/testProcessorNode.go index b1a1c6aaf83..81b0592791b 100644 --- a/integrationTests/testProcessorNode.go +++ b/integrationTests/testProcessorNode.go @@ -141,7 +141,7 @@ var TestAddressPubkeyConverter, _ = pubkeyConverter.NewBech32PubkeyConverter(32, var TestValidatorPubkeyConverter, _ = pubkeyConverter.NewHexPubkeyConverter(96) // TestMultiSig represents a mock multisig -var TestMultiSig = cryptoMocks.NewMultiSigner(1) +var TestMultiSig = cryptoMocks.NewMultiSigner() // TestKeyGenForAccounts represents a mock key generator for balances var TestKeyGenForAccounts = signing.NewKeyGenerator(ed25519.NewEd25519()) @@ -1223,7 +1223,7 @@ func (tpn *TestProcessorNode) initInterceptors(heartbeatPk string) { cryptoComponents.PubKey = nil cryptoComponents.BlockSig = tpn.OwnAccount.BlockSingleSigner cryptoComponents.TxSig = tpn.OwnAccount.SingleSigner - cryptoComponents.MultiSigContainer = TestMultiSig + cryptoComponents.MultiSigContainer = cryptoMocks.NewMultiSignerContainerMock(TestMultiSig) cryptoComponents.BlKeyGen = tpn.OwnAccount.KeygenBlockSign cryptoComponents.TxKeyGen = tpn.OwnAccount.KeygenTxSign @@ -2355,7 +2355,7 @@ func (tpn *TestProcessorNode) initNode() { cryptoComponents.PubKey = tpn.NodeKeys.Pk cryptoComponents.TxSig = tpn.OwnAccount.SingleSigner cryptoComponents.BlockSig = tpn.OwnAccount.SingleSigner - cryptoComponents.MultiSigContainer = tpn.MultiSigner + cryptoComponents.MultiSigContainer = cryptoMocks.NewMultiSignerContainerMock(tpn.MultiSigner) cryptoComponents.BlKeyGen = tpn.OwnAccount.KeygenTxSign cryptoComponents.TxKeyGen = TestKeyGenForAccounts @@ -2530,8 +2530,7 @@ func (tpn *TestProcessorNode) ProposeBlock(round uint64, nonce uint64) (data.Bod log.Warn("blockHeader.SetPrevRandSeed", "error", err.Error()) return nil, nil, nil } - - sig, _ := TestMultiSig.AggregateSigs(nil) + sig := []byte("aggregated signature") err = blockHeader.SetSignature(sig) if err != nil { log.Warn("blockHeader.SetSignature", "error", err.Error()) @@ -2897,7 +2896,7 @@ func (tpn *TestProcessorNode) createHeartbeatWithHardforkTrigger() { cryptoComponents.PubKey = tpn.NodeKeys.Pk cryptoComponents.TxSig = tpn.OwnAccount.SingleSigner cryptoComponents.BlockSig = tpn.OwnAccount.SingleSigner - cryptoComponents.MultiSigContainer = tpn.MultiSigner + cryptoComponents.MultiSigContainer = cryptoMocks.NewMultiSignerContainerMock(tpn.MultiSigner) cryptoComponents.BlKeyGen = tpn.OwnAccount.KeygenTxSign cryptoComponents.TxKeyGen = TestKeyGenForAccounts cryptoComponents.PeerSignHandler = psh @@ -3137,7 +3136,7 @@ func GetDefaultCryptoComponents() *mock.CryptoComponentsStub { PubKeyBytes: []byte("pubKey"), BlockSig: &mock.SignerMock{}, TxSig: &mock.SignerMock{}, - MultiSigContainer: TestMultiSig, + MultiSigContainer: cryptoMocks.NewMultiSignerContainerMock(TestMultiSig), PeerSignHandler: &mock.PeerSignatureHandler{}, BlKeyGen: &mock.KeyGenMock{}, TxKeyGen: &mock.KeyGenMock{}, diff --git a/integrationTests/testProcessorNodeWithCoordinator.go b/integrationTests/testProcessorNodeWithCoordinator.go index 3dc8c5b3e6d..199f85ac10a 100644 --- a/integrationTests/testProcessorNodeWithCoordinator.go +++ b/integrationTests/testProcessorNodeWithCoordinator.go @@ -34,20 +34,6 @@ type nodeKeys struct { BlockSignPkBytes []byte } -func pubKeysMapFromKeysMap(ncp map[uint32][]*nodeKeys) map[uint32][]string { - keysMap := make(map[uint32][]string) - - for shardId, keys := range ncp { - shardKeys := make([]string, len(keys)) - for i, nk := range keys { - shardKeys[i] = string(nk.BlockSignPkBytes) - } - keysMap[shardId] = shardKeys - } - - return keysMap -} - // CreateProcessorNodesWithNodesCoordinator creates a map of nodes with a valid nodes coordinator implementation // keeping the consistency of generated keys func CreateProcessorNodesWithNodesCoordinator( @@ -96,7 +82,7 @@ func CreateProcessorNodesWithNodesCoordinator( IsFullArchive: false, } - nodesCoordinator, err := nodesCoordinator.NewIndexHashedNodesCoordinator(argumentsNodesCoordinator) + nc, err := nodesCoordinator.NewIndexHashedNodesCoordinator(argumentsNodesCoordinator) if err != nil { fmt.Println("error creating node coordinator") } @@ -104,7 +90,7 @@ func CreateProcessorNodesWithNodesCoordinator( tpn := newTestProcessorNodeWithCustomNodesCoordinator( numShards, shardId, - nodesCoordinator, + nc, i, ncp, nodesSetup, @@ -230,15 +216,11 @@ func newTestProcessorNodeWithCustomNodesCoordinator( blsHasher, _ := blake2b.NewBlake2bWithSize(hashing.BlsHashSize) llsig := &multisig2.BlsMultiSigner{Hasher: blsHasher} - pubKeysMap := pubKeysMapFromKeysMap(ncp) kp := ncp[nodeShardId][keyIndex] var err error tpn.MultiSigner, err = multisig.NewBLSMultisig( llsig, - pubKeysMap[nodeShardId], - tpn.NodeKeys.Sk, kp.BlockSignKeyGen, - uint16(keyIndex), ) if err != nil { fmt.Printf("error generating multisigner: %s\n", err) diff --git a/integrationTests/testProcessorNodeWithMultisigner.go b/integrationTests/testProcessorNodeWithMultisigner.go index cd91776e0c7..b21552ab139 100644 --- a/integrationTests/testProcessorNodeWithMultisigner.go +++ b/integrationTests/testProcessorNodeWithMultisigner.go @@ -33,6 +33,7 @@ import ( "github.com/ElrondNetwork/elrond-go/storage/lrucache" "github.com/ElrondNetwork/elrond-go/storage/storageUnit" "github.com/ElrondNetwork/elrond-go/testscommon" + "github.com/ElrondNetwork/elrond-go/testscommon/cryptoMocks" "github.com/ElrondNetwork/elrond-go/testscommon/dblookupext" "github.com/ElrondNetwork/elrond-go/testscommon/nodeTypeProviderMock" "github.com/ElrondNetwork/elrond-go/testscommon/shardingMocks" @@ -87,14 +88,9 @@ func NewTestProcessorNodeWithCustomNodesCoordinator( blsHasher, _ := blake2b.NewBlake2bWithSize(hashing.BlsHashSize) llsig := &mclmultisig.BlsMultiSigner{Hasher: blsHasher} - pubKeysMap := PubKeysMapFromKeysMap(cp.Keys) - tpn.MultiSigner, _ = multisig.NewBLSMultisig( llsig, - pubKeysMap[nodeShardId], - tpn.NodeKeys.Sk, cp.KeyGen, - 0, ) if tpn.MultiSigner == nil { fmt.Println("Error generating multisigner") @@ -281,14 +277,9 @@ func CreateNodeWithBLSAndTxKeys( blsHasher, _ := blake2b.NewBlake2bWithSize(hashing.BlsHashSize) llsig := &mclmultisig.BlsMultiSigner{Hasher: blsHasher} - pubKeysMap := PubKeysMapFromKeysMap(cp.Keys) - tpn.MultiSigner, _ = multisig.NewBLSMultisig( llsig, - pubKeysMap[shardId], - tpn.NodeKeys.Sk, cp.KeyGen, - 0, ) if tpn.MultiSigner == nil { fmt.Println("Error generating multisigner") @@ -545,7 +536,7 @@ func CreateNodesWithNodesCoordinatorAndHeaderSigVerifier( Marshalizer: TestMarshalizer, Hasher: TestHasher, NodesCoordinator: nodesCoordinatorInstance, - MultiSigVerifier: TestMultiSig, + MultiSigContainer: cryptoMocks.NewMultiSignerContainerMock(TestMultiSig), SingleSigVerifier: signer, KeyGen: keyGen, FallbackHeaderValidator: &testscommon.FallBackHeaderValidatorStub{}, @@ -653,7 +644,7 @@ func CreateNodesWithNodesCoordinatorKeygenAndSingleSigner( Marshalizer: TestMarshalizer, Hasher: TestHasher, NodesCoordinator: nodesCoord, - MultiSigVerifier: TestMultiSig, + MultiSigContainer: cryptoMocks.NewMultiSignerContainerMock(TestMultiSig), SingleSigVerifier: singleSigner, KeyGen: keyGenForBlocks, FallbackHeaderValidator: &testscommon.FallBackHeaderValidatorStub{}, @@ -766,17 +757,17 @@ func DoConsensusSigningOnBlock( blockHeaderHash, _ := core.CalculateHash(TestMarshalizer, TestHasher, blockHeader) - var msig crypto.MultiSigner - msigProposer, _ := consensusNodes[0].MultiSigner.Create(pubKeys, 0) - _, _ = msigProposer.CreateSignatureShare(blockHeaderHash, bitmap) + pubKeysBytes := make([][]byte, len(consensusNodes)) + sigShares := make([][]byte, len(consensusNodes)) + msig := consensusNodes[0].MultiSigner - for i := 1; i < len(consensusNodes); i++ { - msig, _ = consensusNodes[i].MultiSigner.Create(pubKeys, uint16(i)) - sigShare, _ := msig.CreateSignatureShare(blockHeaderHash, bitmap) - _ = msigProposer.StoreSignatureShare(uint16(i), sigShare) + for i := 0; i < len(consensusNodes); i++ { + pubKeysBytes[i] = []byte(pubKeys[i]) + sk, _ := consensusNodes[i].NodeKeys.Sk.ToByteArray() + sigShares[i], _ = msig.CreateSignatureShare(sk, blockHeaderHash) } - sig, _ := msigProposer.AggregateSigs(bitmap) + sig, _ := msig.AggregateSigs(pubKeysBytes, sigShares) err = blockHeader.SetSignature(sig) if err != nil { log.Error("blockHeader.SetSignature", "error", err) diff --git a/node/nodeTesting_test.go b/node/nodeTesting_test.go index 3554b5557bd..6982b386990 100644 --- a/node/nodeTesting_test.go +++ b/node/nodeTesting_test.go @@ -388,18 +388,18 @@ func TestGenerateAndSendBulkTransactions_ShouldWork(t *testing.T) { func getDefaultCryptoComponents() *factoryMock.CryptoComponentsMock { return &factoryMock.CryptoComponentsMock{ - PubKey: &mock.PublicKeyMock{}, - PrivKey: &mock.PrivateKeyStub{}, - PubKeyString: "pubKey", - PrivKeyBytes: []byte("privKey"), - PubKeyBytes: []byte("pubKey"), - BlockSig: &mock.SingleSignerMock{}, - TxSig: &mock.SingleSignerMock{}, - MultiSig: cryptoMocks.NewMultiSigner(1), - PeerSignHandler: &mock.PeerSignatureHandler{}, - BlKeyGen: &mock.KeyGenMock{}, - TxKeyGen: &mock.KeyGenMock{}, - MsgSigVerifier: &testscommon.MessageSignVerifierMock{}, + PubKey: &mock.PublicKeyMock{}, + PrivKey: &mock.PrivateKeyStub{}, + PubKeyString: "pubKey", + PrivKeyBytes: []byte("privKey"), + PubKeyBytes: []byte("pubKey"), + BlockSig: &mock.SingleSignerMock{}, + TxSig: &mock.SingleSignerMock{}, + MultiSigContainer: cryptoMocks.NewMultiSignerContainerMock(cryptoMocks.NewMultiSigner()), + PeerSignHandler: &mock.PeerSignatureHandler{}, + BlKeyGen: &mock.KeyGenMock{}, + TxKeyGen: &mock.KeyGenMock{}, + MsgSigVerifier: &testscommon.MessageSignVerifierMock{}, } } diff --git a/p2p/libp2p/p2pSigner.go b/p2p/libp2p/p2pSigner.go index 3be693c95fb..e2c600ea4ec 100644 --- a/p2p/libp2p/p2pSigner.go +++ b/p2p/libp2p/p2pSigner.go @@ -35,7 +35,7 @@ func (signer *p2pSigner) Verify(payload []byte, pid core.PeerID, signature []byt return err } if !sigOk { - return crypto.ErrInvalidSignature + return crypto.ErrSigNotValid } return nil diff --git a/p2p/libp2p/p2pSigner_test.go b/p2p/libp2p/p2pSigner_test.go index e373c00a082..3e4ad3ad5b0 100644 --- a/p2p/libp2p/p2pSigner_test.go +++ b/p2p/libp2p/p2pSigner_test.go @@ -75,7 +75,7 @@ func TestP2pSigner_Verify(t *testing.T) { sig[len(sig)-1] = sig[0] ^ sig[1] ^ sig[2] err = signer.Verify(payload, core.PeerID(libp2pPid), sig) - assert.Equal(t, crypto.ErrInvalidSignature, err) + assert.Equal(t, crypto.ErrSigNotValid, err) }) t.Run("sign and verify should work", func(t *testing.T) { t.Parallel() diff --git a/process/factory/interceptorscontainer/shardInterceptorsContainerFactory_test.go b/process/factory/interceptorscontainer/shardInterceptorsContainerFactory_test.go index 5abc7ab2218..01bcf64252f 100644 --- a/process/factory/interceptorscontainer/shardInterceptorsContainerFactory_test.go +++ b/process/factory/interceptorscontainer/shardInterceptorsContainerFactory_test.go @@ -685,7 +685,7 @@ func createMockComponentHolders() (*mock.CoreComponentsMock, *mock.CryptoCompone TxVersionCheckField: versioning.NewTxVersionChecker(1), HardforkTriggerPubKeyField: providedHardforkPubKey, } - multiSigner := cryptoMocks.NewMultiSigner(21) + multiSigner := cryptoMocks.NewMultiSigner() cryptoComponents := &mock.CryptoComponentsMock{ BlockSig: &mock.SignerMock{}, TxSig: &mock.SignerMock{}, diff --git a/process/headerCheck/errors.go b/process/headerCheck/errors.go index 443cea6dc84..152e5c62dfa 100644 --- a/process/headerCheck/errors.go +++ b/process/headerCheck/errors.go @@ -17,3 +17,9 @@ var ErrInvalidChainID = errors.New("invalid chain ID") // ErrNilHeaderVersionHandler signals that the provided header version handler is nil var ErrNilHeaderVersionHandler = errors.New("nil header version handler") + +// ErrIndexOutOfBounds signals that the given index is outside of expected bounds +var ErrIndexOutOfBounds = errors.New("index is out of bounds") + +// ErrIndexNotSelected signals that the given index is not selected +var ErrIndexNotSelected = errors.New("index is not selected") diff --git a/process/headerCheck/headerSignatureVerify.go b/process/headerCheck/headerSignatureVerify.go index 601ea5b1dd5..e424ef68677 100644 --- a/process/headerCheck/headerSignatureVerify.go +++ b/process/headerCheck/headerSignatureVerify.go @@ -95,15 +95,28 @@ func checkArgsHeaderSigVerifier(arguments *ArgsHeaderSigVerifier) error { return nil } -// VerifySignature will check if signature is correct -func (hsv *HeaderSigVerifier) VerifySignature(header data.HeaderHandler) error { +func isIndexInBitmap(index uint16, bitmap []byte) error { + indexOutOfBounds := index >= uint16(len(bitmap)*8) + if indexOutOfBounds { + return ErrIndexOutOfBounds + } + + indexNotInBitmap := bitmap[index/8]&(1<= uint16(len(mm.pubkeys)) { - return crypto.ErrIndexOutOfBounds - } - - mm.sigs[index] = sig - return nil + return bytes.Repeat([]byte("0xAA"), signatureSize), nil } // VerifySignatureShare - -func (mm *MultisignerMock) VerifySignatureShare(index uint16, sig []byte, msg []byte, bitmap []byte) error { +func (mm *MultisignerMock) VerifySignatureShare(publicKey []byte, message []byte, sig []byte) error { if mm.VerifySignatureShareCalled != nil { - return mm.VerifySignatureShareCalled(index, sig, msg, bitmap) + return mm.VerifySignatureShareCalled(publicKey, message, sig) } - return nil } // AggregateSigs - -func (mm *MultisignerMock) AggregateSigs(bitmap []byte) ([]byte, error) { +func (mm *MultisignerMock) AggregateSigs(pubKeysSigners [][]byte, signatures [][]byte) ([]byte, error) { if mm.AggregateSigsCalled != nil { - return mm.AggregateSigsCalled(bitmap) - } - - return mm.aggSig, nil -} - -// SignatureShare - -func (mm *MultisignerMock) SignatureShare(index uint16) ([]byte, error) { - if mm.SignatureShareCalled != nil { - return mm.SignatureShareCalled(index) - } - - if index >= uint16(len(mm.sigs)) { - return nil, crypto.ErrIndexOutOfBounds + return mm.AggregateSigsCalled(pubKeysSigners, signatures) } - return mm.sigs[index], nil + return bytes.Repeat([]byte("0xAA"), signatureSize), nil } -// CreateAndAddSignatureShareForKey - -func (mm *MultisignerMock) CreateAndAddSignatureShareForKey(message []byte, privateKey crypto.PrivateKey, pubKeyBytes []byte) ([]byte, error) { - if mm.CreateAndAddSignatureShareForKeyCalled != nil { - return mm.CreateAndAddSignatureShareForKeyCalled(message, privateKey, pubKeyBytes) +// VerifyAggregatedSig - +func (mm *MultisignerMock) VerifyAggregatedSig(pubKeysSigners [][]byte, message []byte, aggSig []byte) error { + if mm.VerifyAggregatedSigCalled != nil { + return mm.VerifyAggregatedSigCalled(pubKeysSigners, message, aggSig) } - - return nil, nil + return nil } // IsInterfaceNil - diff --git a/testscommon/cryptoMocks/multisignerStub.go b/testscommon/cryptoMocks/multisignerStub.go deleted file mode 100644 index 4f2d4291bf2..00000000000 --- a/testscommon/cryptoMocks/multisignerStub.go +++ /dev/null @@ -1,112 +0,0 @@ -package cryptoMocks - -import crypto "github.com/ElrondNetwork/elrond-go-crypto" - -// MultisignerStub - -type MultisignerStub struct { - CreateCalled func(pubKeys []string, index uint16) (crypto.MultiSigner, error) - SetAggregatedSigCalled func(bytes []byte) error - VerifyCalled func(msg []byte, bitmap []byte) error - ResetCalled func(pubKeys []string, index uint16) error - CreateSignatureShareCalled func(msg []byte, bitmap []byte) ([]byte, error) - StoreSignatureShareCalled func(index uint16, sig []byte) error - SignatureShareCalled func(index uint16) ([]byte, error) - VerifySignatureShareCalled func(index uint16, sig []byte, msg []byte, bitmap []byte) error - AggregateSigsCalled func(bitmap []byte) ([]byte, error) - CreateAndAddSignatureShareForKeyCalled func(message []byte, privateKey crypto.PrivateKey, pubKeyBytes []byte) ([]byte, error) -} - -// Create - -func (mss *MultisignerStub) Create(pubKeys []string, index uint16) (crypto.MultiSigner, error) { - if mss.CreateCalled != nil { - return mss.CreateCalled(pubKeys, index) - } - - return nil, nil -} - -// SetAggregatedSig - -func (mss *MultisignerStub) SetAggregatedSig(bytes []byte) error { - if mss.SetAggregatedSigCalled != nil { - return mss.SetAggregatedSigCalled(bytes) - } - - return nil -} - -// Verify - -func (mss *MultisignerStub) Verify(msg []byte, bitmap []byte) error { - if mss.VerifyCalled != nil { - return mss.VerifyCalled(msg, bitmap) - } - - return nil -} - -// Reset - -func (mss *MultisignerStub) Reset(pubKeys []string, index uint16) error { - if mss.ResetCalled != nil { - return mss.ResetCalled(pubKeys, index) - } - - return nil -} - -// CreateSignatureShare - -func (mss *MultisignerStub) CreateSignatureShare(msg []byte, bitmap []byte) ([]byte, error) { - if mss.CreateSignatureShareCalled != nil { - return mss.CreateSignatureShareCalled(msg, bitmap) - } - - return nil, nil -} - -// StoreSignatureShare - -func (mss *MultisignerStub) StoreSignatureShare(index uint16, sig []byte) error { - if mss.StoreSignatureShareCalled != nil { - return mss.StoreSignatureShareCalled(index, sig) - } - - return nil -} - -// SignatureShare - -func (mss *MultisignerStub) SignatureShare(index uint16) ([]byte, error) { - if mss.SignatureShareCalled != nil { - return mss.SignatureShareCalled(index) - } - - return nil, nil -} - -// VerifySignatureShare - -func (mss *MultisignerStub) VerifySignatureShare(index uint16, sig []byte, msg []byte, bitmap []byte) error { - if mss.VerifySignatureShareCalled != nil { - return mss.VerifySignatureShareCalled(index, sig, msg, bitmap) - } - - return nil -} - -// AggregateSigs - -func (mss *MultisignerStub) AggregateSigs(bitmap []byte) ([]byte, error) { - if mss.AggregateSigsCalled != nil { - return mss.AggregateSigsCalled(bitmap) - } - - return nil, nil -} - -// CreateAndAddSignatureShareForKey - -func (mss *MultisignerStub) CreateAndAddSignatureShareForKey(message []byte, privateKey crypto.PrivateKey, pubKeyBytes []byte) ([]byte, error) { - if mss.CreateAndAddSignatureShareForKeyCalled != nil { - return mss.CreateAndAddSignatureShareForKeyCalled(message, privateKey, pubKeyBytes) - } - - return nil, nil -} - -// IsInterfaceNil - -func (mss *MultisignerStub) IsInterfaceNil() bool { - return mss == nil -} From 2791efc2071e927183dbf5025b99b6e112e5ce06 Mon Sep 17 00:00:00 2001 From: AdoAdoAdo Date: Fri, 22 Jul 2022 15:19:08 +0300 Subject: [PATCH 04/10] consensus: fix unit tests after multisigner integration --- consensus/mock/consensusDataContainerMock.go | 4 +- .../spos/bls/blsSubroundsFactory_test.go | 6 +- consensus/spos/bls/subroundBlock_test.go | 6 +- consensus/spos/bls/subroundEndRound_test.go | 11 +- consensus/spos/bls/subroundSignature.go | 9 ++ consensus/spos/bls/subroundSignature_test.go | 98 ++----------- consensus/spos/bls/subroundStartRound_test.go | 24 +--- consensus/spos/consensusCoreValidator.go | 4 + consensus/spos/consensusCoreValidator_test.go | 13 +- consensus/spos/consensusCore_test.go | 17 ++- consensus/spos/errors.go | 3 + consensus/spos/subround_test.go | 5 +- factory/crypto/multiSignerContainer_test.go | 90 ++++++++++++ integrationTests/multisig/blsMultisig_test.go | 135 +++--------------- 14 files changed, 185 insertions(+), 240 deletions(-) create mode 100644 factory/crypto/multiSignerContainer_test.go diff --git a/consensus/mock/consensusDataContainerMock.go b/consensus/mock/consensusDataContainerMock.go index d44c3704589..6b21faf0e9c 100644 --- a/consensus/mock/consensusDataContainerMock.go +++ b/consensus/mock/consensusDataContainerMock.go @@ -156,8 +156,8 @@ func (ccm *ConsensusCoreMock) SetMarshalizer(marshalizer marshal.Marshalizer) { } // SetMultiSignerContainer - -func (ccm *ConsensusCoreMock) SetMultiSignerContainer(multiSigner cryptoCommon.MultiSignerContainer) { - ccm.multiSignerContainer = multiSigner +func (ccm *ConsensusCoreMock) SetMultiSignerContainer(multiSignerContainer cryptoCommon.MultiSignerContainer) { + ccm.multiSignerContainer = multiSignerContainer } // SetRoundHandler - diff --git a/consensus/spos/bls/blsSubroundsFactory_test.go b/consensus/spos/bls/blsSubroundsFactory_test.go index a973653ef15..92a00a1956c 100644 --- a/consensus/spos/bls/blsSubroundsFactory_test.go +++ b/consensus/spos/bls/blsSubroundsFactory_test.go @@ -275,13 +275,13 @@ func TestFactory_NewFactoryNilMarshalizerShouldFail(t *testing.T) { assert.Equal(t, spos.ErrNilMarshalizer, err) } -func TestFactory_NewFactoryNilMultiSignerShouldFail(t *testing.T) { +func TestFactory_NewFactoryNilMultiSignerContainerShouldFail(t *testing.T) { t.Parallel() consensusState := initConsensusState() container := mock.InitConsensusCore() worker := initWorker() - container.SetMultiSigner(nil) + container.SetMultiSignerContainer(nil) fct, err := bls.NewSubroundsFactory( container, @@ -293,7 +293,7 @@ func TestFactory_NewFactoryNilMultiSignerShouldFail(t *testing.T) { ) assert.Nil(t, fct) - assert.Equal(t, spos.ErrNilMultiSigner, err) + assert.Equal(t, spos.ErrNilMultiSignerContainer, err) } func TestFactory_NewFactoryNilRoundHandlerShouldFail(t *testing.T) { diff --git a/consensus/spos/bls/subroundBlock_test.go b/consensus/spos/bls/subroundBlock_test.go index 21130cb280b..e430309f722 100644 --- a/consensus/spos/bls/subroundBlock_test.go +++ b/consensus/spos/bls/subroundBlock_test.go @@ -216,7 +216,7 @@ func TestSubroundBlock_NewSubroundBlockNilMarshalizerShouldFail(t *testing.T) { assert.Equal(t, spos.ErrNilMarshalizer, err) } -func TestSubroundBlock_NewSubroundBlockNilMultisignerShouldFail(t *testing.T) { +func TestSubroundBlock_NewSubroundBlockNilMultiSignerContainerShouldFail(t *testing.T) { t.Parallel() container := mock.InitConsensusCore() @@ -225,10 +225,10 @@ func TestSubroundBlock_NewSubroundBlockNilMultisignerShouldFail(t *testing.T) { ch := make(chan bool, 1) sr, _ := defaultSubroundForSRBlock(consensusState, ch, container, &statusHandler.AppStatusHandlerStub{}) - container.SetMultiSigner(nil) + container.SetMultiSignerContainer(nil) srBlock, err := defaultSubroundBlockFromSubround(sr) assert.Nil(t, srBlock) - assert.Equal(t, spos.ErrNilMultiSigner, err) + assert.Equal(t, spos.ErrNilMultiSignerContainer, err) } func TestSubroundBlock_NewSubroundBlockNilRoundHandlerShouldFail(t *testing.T) { diff --git a/consensus/spos/bls/subroundEndRound_test.go b/consensus/spos/bls/subroundEndRound_test.go index e102e356863..1ba8e208196 100644 --- a/consensus/spos/bls/subroundEndRound_test.go +++ b/consensus/spos/bls/subroundEndRound_test.go @@ -14,6 +14,7 @@ import ( "github.com/ElrondNetwork/elrond-go/consensus/spos" "github.com/ElrondNetwork/elrond-go/consensus/spos/bls" "github.com/ElrondNetwork/elrond-go/dataRetriever/blockchain" + "github.com/ElrondNetwork/elrond-go/testscommon/cryptoMocks" "github.com/ElrondNetwork/elrond-go/testscommon/statusHandler" "github.com/stretchr/testify/assert" "github.com/stretchr/testify/require" @@ -177,7 +178,7 @@ func TestSubroundEndRound_NewSubroundEndRoundNilConsensusStateShouldFail(t *test assert.Equal(t, spos.ErrNilConsensusState, err) } -func TestSubroundEndRound_NewSubroundEndRoundNilMultisignerShouldFail(t *testing.T) { +func TestSubroundEndRound_NewSubroundEndRoundNilMultiSignerContainerShouldFail(t *testing.T) { t.Parallel() container := mock.InitConsensusCore() @@ -199,7 +200,7 @@ func TestSubroundEndRound_NewSubroundEndRoundNilMultisignerShouldFail(t *testing currentPid, &statusHandler.AppStatusHandlerStub{}, ) - container.SetMultiSigner(nil) + container.SetMultiSignerContainer(nil) srEndRound, err := bls.NewSubroundEndRound( sr, extend, @@ -209,7 +210,7 @@ func TestSubroundEndRound_NewSubroundEndRoundNilMultisignerShouldFail(t *testing ) assert.Nil(t, srEndRound) - assert.Equal(t, spos.ErrNilMultiSigner, err) + assert.Equal(t, spos.ErrNilMultiSignerContainer, err) } func TestSubroundEndRound_NewSubroundEndRoundNilRoundHandlerShouldFail(t *testing.T) { @@ -322,11 +323,11 @@ func TestSubroundEndRound_DoEndRoundJobErrAggregatingSigShouldFail(t *testing.T) container := mock.InitConsensusCore() sr := *initSubroundEndRoundWithContainer(container, &statusHandler.AppStatusHandlerStub{}) multiSignerMock := mock.InitMultiSignerMock() - multiSignerMock.AggregateSigsCalled = func(bitmap []byte) ([]byte, error) { + multiSignerMock.AggregateSigsCalled = func(pubKeysSigners [][]byte, signatures [][]byte) ([]byte, error) { return nil, crypto.ErrNilHasher } - container.SetMultiSigner(multiSignerMock) + container.SetMultiSignerContainer(cryptoMocks.NewMultiSignerContainerMock(multiSignerMock)) sr.Header = &block.Header{} sr.SetSelfPubKey("A") diff --git a/consensus/spos/bls/subroundSignature.go b/consensus/spos/bls/subroundSignature.go index c2ffdc90913..44fa9c3684a 100644 --- a/consensus/spos/bls/subroundSignature.go +++ b/consensus/spos/bls/subroundSignature.go @@ -68,6 +68,10 @@ func (sr *subroundSignature) doSignatureJob(_ context.Context) bool { if !sr.CanDoSubroundJob(sr.Current()) { return false } + if sr.Header == nil { + log.Error("doSignatureJob", "error", spos.ErrNilHeader) + return false + } multiSigner, err := sr.MultiSignerContainer().GetMultiSigner(sr.Header.GetEpoch()) if err != nil { @@ -168,6 +172,11 @@ func (sr *subroundSignature) receivedSignature(_ context.Context, cnsDta *consen return false } + if sr.Header == nil { + log.Error("receivedSignature", "error", spos.ErrNilHeader) + return false + } + currentMultiSigner, err := sr.MultiSignerContainer().GetMultiSigner(sr.Header.GetEpoch()) if err != nil { log.Error("receivedSignature.GetMultiSigner", "error", err.Error()) diff --git a/consensus/spos/bls/subroundSignature_test.go b/consensus/spos/bls/subroundSignature_test.go index 7af1080c00b..1e4240a09a3 100644 --- a/consensus/spos/bls/subroundSignature_test.go +++ b/consensus/spos/bls/subroundSignature_test.go @@ -4,6 +4,7 @@ import ( "testing" "github.com/ElrondNetwork/elrond-go-core/data" + "github.com/ElrondNetwork/elrond-go-core/data/block" "github.com/ElrondNetwork/elrond-go/consensus" "github.com/ElrondNetwork/elrond-go/consensus/mock" "github.com/ElrondNetwork/elrond-go/consensus/spos" @@ -129,7 +130,7 @@ func TestSubroundSignature_NewSubroundSignatureNilHasherShouldFail(t *testing.T) assert.Equal(t, spos.ErrNilHasher, err) } -func TestSubroundSignature_NewSubroundSignatureNilMultisignerShouldFail(t *testing.T) { +func TestSubroundSignature_NewSubroundSignatureNilMultiSignerContainerShouldFail(t *testing.T) { t.Parallel() container := mock.InitConsensusCore() @@ -151,7 +152,7 @@ func TestSubroundSignature_NewSubroundSignatureNilMultisignerShouldFail(t *testi currentPid, &statusHandler.AppStatusHandlerStub{}, ) - container.SetMultiSigner(nil) + container.SetMultiSignerContainer(nil) srSignature, err := bls.NewSubroundSignature( sr, extend, @@ -159,7 +160,7 @@ func TestSubroundSignature_NewSubroundSignatureNilMultisignerShouldFail(t *testi ) assert.Nil(t, srSignature) - assert.Equal(t, spos.ErrNilMultiSigner, err) + assert.Equal(t, spos.ErrNilMultiSignerContainer, err) } func TestSubroundSignature_NewSubroundSignatureNilRoundHandlerShouldFail(t *testing.T) { @@ -268,6 +269,7 @@ func TestSubroundSignature_DoSignatureJob(t *testing.T) { container := mock.InitConsensusCore() sr := *initSubroundSignatureWithContainer(container) + sr.Header = &block.Header{} sr.Data = nil r := sr.DoSignatureJob() assert.False(t, r) @@ -281,7 +283,7 @@ func TestSubroundSignature_DoSignatureJob(t *testing.T) { return nil, err } - container.SetMultiSigner(multiSignerMock) + container.SetMultiSignerContainer(cryptoMocks.NewMultiSignerContainerMock(multiSignerMock)) r = sr.DoSignatureJob() assert.False(t, r) @@ -291,7 +293,7 @@ func TestSubroundSignature_DoSignatureJob(t *testing.T) { multiSignerMock.CreateSignatureShareCalled = func(msg []byte, bitmap []byte) ([]byte, error) { return []byte("SIG"), nil } - container.SetMultiSigner(multiSignerMock) + container.SetMultiSignerContainer(cryptoMocks.NewMultiSignerContainerMock(multiSignerMock)) r = sr.DoSignatureJob() assert.True(t, r) @@ -325,6 +327,7 @@ func TestSubroundSignature_ReceivedSignature(t *testing.T) { currentPid, ) + sr.Header = &block.Header{} sr.Data = nil r := sr.ReceivedSignature(cnsMsg) assert.False(t, r) @@ -363,15 +366,12 @@ func TestSubroundSignature_ReceivedSignatureVerifyShareFailed(t *testing.T) { t.Parallel() errVerify := errors.New("signature share verification failed") - multiSigner := cryptoMocks.NewMultiSigner(21) - multiSigner.VerifySignatureShareCalled = func(index uint16, sig []byte, msg []byte, bitmap []byte) error { + multiSigner := cryptoMocks.NewMultiSigner() + verifyCalled := false + multiSigner.VerifySignatureShareCalled = func(publicKey []byte, message []byte, sig []byte) error { + verifyCalled = true return errVerify } - storeSigShareCalled := false - multiSigner.StoreSignatureShareCalled = func(index uint16, sig []byte) error { - storeSigShareCalled = true - return nil - } container := mock.InitConsensusCoreWithMultiSigner(multiSigner) sr := *initSubroundSignatureWithContainer(container) @@ -423,81 +423,11 @@ func TestSubroundSignature_ReceivedSignatureVerifyShareFailed(t *testing.T) { } } } - r = sr.ReceivedSignature(cnsMsg) - assert.False(t, r) - assert.False(t, storeSigShareCalled) -} - -func TestSubroundSignature_ReceivedSignatureStoreShareFailed(t *testing.T) { - t.Parallel() - - errStore := errors.New("signature share store failed") - multiSigner := cryptoMocks.NewMultiSigner(21) - verifySigShareCalled := false - multiSigner.VerifySignatureShareCalled = func(index uint16, sig []byte, msg []byte, bitmap []byte) error { - verifySigShareCalled = true - return nil - } - storeSigShareCalled := false - multiSigner.StoreSignatureShareCalled = func(index uint16, sig []byte) error { - storeSigShareCalled = true - return errStore - } - - container := mock.InitConsensusCoreWithMultiSigner(multiSigner) - sr := *initSubroundSignatureWithContainer(container) - - signature := []byte("signature") - cnsMsg := consensus.NewConsensusMessage( - sr.Data, - signature, - nil, - nil, - []byte(sr.ConsensusGroup()[1]), - []byte("sig"), - int(bls.MtSignature), - 0, - chainID, - nil, - nil, - nil, - currentPid, - ) - sr.Data = nil - r := sr.ReceivedSignature(cnsMsg) - assert.False(t, r) - - sr.Data = []byte("Y") - r = sr.ReceivedSignature(cnsMsg) - assert.False(t, r) - - sr.Data = []byte("X") - r = sr.ReceivedSignature(cnsMsg) - assert.False(t, r) - - sr.SetSelfPubKey(sr.ConsensusGroup()[0]) - - cnsMsg.PubKey = []byte("X") - r = sr.ReceivedSignature(cnsMsg) - assert.False(t, r) - - cnsMsg.PubKey = []byte(sr.ConsensusGroup()[1]) - maxCount := len(sr.ConsensusGroup()) * 2 / 3 - count := 0 - for i := 0; i < len(sr.ConsensusGroup()); i++ { - if sr.ConsensusGroup()[i] != string(cnsMsg.PubKey) { - _ = sr.SetJobDone(sr.ConsensusGroup()[i], bls.SrSignature, true) - count++ - if count == maxCount { - break - } - } - } + sr.Header = &block.Header{Epoch: 0} r = sr.ReceivedSignature(cnsMsg) assert.False(t, r) - assert.True(t, storeSigShareCalled) - assert.True(t, verifySigShareCalled) + assert.True(t, verifyCalled) } func TestSubroundSignature_SignaturesCollected(t *testing.T) { diff --git a/consensus/spos/bls/subroundStartRound_test.go b/consensus/spos/bls/subroundStartRound_test.go index 128c9e2a918..f2d296eb3b5 100644 --- a/consensus/spos/bls/subroundStartRound_test.go +++ b/consensus/spos/bls/subroundStartRound_test.go @@ -145,7 +145,7 @@ func TestSubroundStartRound_NewSubroundStartRoundNilConsensusStateShouldFail(t * assert.Equal(t, spos.ErrNilConsensusState, err) } -func TestSubroundStartRound_NewSubroundStartRoundNilMultiSignerShouldFail(t *testing.T) { +func TestSubroundStartRound_NewSubroundStartRoundNilMultiSignerContainerShouldFail(t *testing.T) { t.Parallel() container := mock.InitConsensusCore() @@ -154,11 +154,11 @@ func TestSubroundStartRound_NewSubroundStartRoundNilMultiSignerShouldFail(t *tes ch := make(chan bool, 1) sr, _ := defaultSubround(consensusState, ch, container) - container.SetMultiSigner(nil) + container.SetMultiSignerContainer(nil) srStartRound, err := defaultSubroundStartRoundFromSubround(sr) assert.Nil(t, srStartRound) - assert.Equal(t, spos.ErrNilMultiSigner, err) + assert.Equal(t, spos.ErrNilMultiSignerContainer, err) } func TestSubroundStartRound_NewSubroundStartRoundNilRoundHandlerShouldFail(t *testing.T) { @@ -385,24 +385,6 @@ func TestSubroundStartRound_InitCurrentRoundShouldReturnTrueWhenIsNotInTheConsen assert.True(t, r) } -func TestSubroundStartRound_InitCurrentRoundShouldReturnFalseWhenCreateErr(t *testing.T) { - t.Parallel() - - multiSignerMock := mock.InitMultiSignerMock() - err := errors.New("error") - multiSignerMock.ResetCalled = func(pubKeys []string, index uint16) error { - return err - } - - container := mock.InitConsensusCore() - container.SetMultiSigner(multiSignerMock) - - srStartRound := *initSubroundStartRoundWithContainer(container) - - r := srStartRound.InitCurrentRound() - assert.False(t, r) -} - func TestSubroundStartRound_InitCurrentRoundShouldReturnFalseWhenTimeIsOut(t *testing.T) { t.Parallel() diff --git a/consensus/spos/consensusCoreValidator.go b/consensus/spos/consensusCoreValidator.go index d8360627493..04071540569 100644 --- a/consensus/spos/consensusCoreValidator.go +++ b/consensus/spos/consensusCoreValidator.go @@ -29,6 +29,10 @@ func ValidateConsensusCore(container ConsensusCoreHandler) error { return ErrNilMarshalizer } if check.IfNil(container.MultiSignerContainer()) { + return ErrNilMultiSignerContainer + } + multiSigner, _ := container.MultiSignerContainer().GetMultiSigner(0) + if check.IfNil(multiSigner) { return ErrNilMultiSigner } if check.IfNil(container.RoundHandler()) { diff --git a/consensus/spos/consensusCoreValidator_test.go b/consensus/spos/consensusCoreValidator_test.go index f898fc2a3db..33cde1a5982 100644 --- a/consensus/spos/consensusCoreValidator_test.go +++ b/consensus/spos/consensusCoreValidator_test.go @@ -122,7 +122,7 @@ func TestConsensusContainerValidator_ValidateNilMarshalizerShouldFail(t *testing assert.Equal(t, ErrNilMarshalizer, err) } -func TestConsensusContainerValidator_ValidateNilMultiSignerShouldFail(t *testing.T) { +func TestConsensusContainerValidator_ValidateNilMultiSignerContainerShouldFail(t *testing.T) { t.Parallel() container := initConsensusDataContainer() @@ -130,6 +130,17 @@ func TestConsensusContainerValidator_ValidateNilMultiSignerShouldFail(t *testing err := ValidateConsensusCore(container) + assert.Equal(t, ErrNilMultiSignerContainer, err) +} + +func TestConsensusContainerValidator_ValidateNilMultiSignerShouldFail(t *testing.T) { + t.Parallel() + + container := initConsensusDataContainer() + container.multiSignerContainer = cryptoMocks.NewMultiSignerContainerMock(nil) + + err := ValidateConsensusCore(container) + assert.Equal(t, ErrNilMultiSigner, err) } diff --git a/consensus/spos/consensusCore_test.go b/consensus/spos/consensusCore_test.go index 6e31c6d8cd6..082ceec0733 100644 --- a/consensus/spos/consensusCore_test.go +++ b/consensus/spos/consensusCore_test.go @@ -6,6 +6,7 @@ import ( "github.com/ElrondNetwork/elrond-go/consensus/mock" "github.com/ElrondNetwork/elrond-go/consensus/spos" "github.com/ElrondNetwork/elrond-go/testscommon/consensus" + "github.com/ElrondNetwork/elrond-go/testscommon/cryptoMocks" "github.com/stretchr/testify/assert" ) @@ -164,7 +165,7 @@ func TestConsensusCore_WithNilBlsSingleSignerShouldFail(t *testing.T) { assert.Equal(t, spos.ErrNilBlsSingleSigner, err) } -func TestConsensusCore_WithNilMultiSignerShouldFail(t *testing.T) { +func TestConsensusCore_WithNilMultiSignerContainerShouldFail(t *testing.T) { t.Parallel() args := createDefaultConsensusCoreArgs() @@ -174,6 +175,20 @@ func TestConsensusCore_WithNilMultiSignerShouldFail(t *testing.T) { args, ) + assert.Nil(t, consensusCore) + assert.Equal(t, spos.ErrNilMultiSignerContainer, err) +} + +func TestConsensusCore_WithNilMultiSignerShouldFail(t *testing.T) { + t.Parallel() + + args := createDefaultConsensusCoreArgs() + args.MultiSignerContainer = cryptoMocks.NewMultiSignerContainerMock(nil) + + consensusCore, err := spos.NewConsensusCore( + args, + ) + assert.Nil(t, consensusCore) assert.Equal(t, spos.ErrNilMultiSigner, err) } diff --git a/consensus/spos/errors.go b/consensus/spos/errors.go index 33def746ddb..40e4ff8371b 100644 --- a/consensus/spos/errors.go +++ b/consensus/spos/errors.go @@ -22,6 +22,9 @@ var ErrNilSignature = errors.New("signature is nil") // ErrNilMultiSigner is raised when a valid multiSigner is expected but nil used var ErrNilMultiSigner = errors.New("multiSigner is nil") +// ErrNilMultiSignerContainer is raised when a valid multiSigner container is expected, but nil used +var ErrNilMultiSignerContainer = errors.New("multiSigner container is nil") + // ErrNilConsensusState is raised when a valid consensus is expected but nil used var ErrNilConsensusState = errors.New("consensus state is nil") diff --git a/consensus/spos/subround_test.go b/consensus/spos/subround_test.go index 33489efc82a..f2adc42ffcb 100644 --- a/consensus/spos/subround_test.go +++ b/consensus/spos/subround_test.go @@ -10,6 +10,7 @@ import ( "github.com/ElrondNetwork/elrond-go/consensus/mock" "github.com/ElrondNetwork/elrond-go/consensus/spos" "github.com/ElrondNetwork/elrond-go/consensus/spos/bls" + "github.com/ElrondNetwork/elrond-go/testscommon/cryptoMocks" "github.com/ElrondNetwork/elrond-go/testscommon/statusHandler" "github.com/stretchr/testify/assert" ) @@ -357,13 +358,13 @@ func TestSubround_NilContainerMarshalizerShouldFail(t *testing.T) { assert.Equal(t, spos.ErrNilMarshalizer, err) } -func TestSubround_NilContainerMultisignerShouldFail(t *testing.T) { +func TestSubround_NilContainerMultiSignerShouldFail(t *testing.T) { t.Parallel() consensusState := initConsensusState() ch := make(chan bool, 1) container := mock.InitConsensusCore() - container.SetMultiSignerContainer(nil) + container.SetMultiSignerContainer(cryptoMocks.NewMultiSignerContainerMock(nil)) sr, err := spos.NewSubround( -1, diff --git a/factory/crypto/multiSignerContainer_test.go b/factory/crypto/multiSignerContainer_test.go new file mode 100644 index 00000000000..98fe6642fe0 --- /dev/null +++ b/factory/crypto/multiSignerContainer_test.go @@ -0,0 +1,90 @@ +package crypto_test + +import ( + "testing" +) + +func Test_NewMultiSignerContainer(t *testing.T) { + +} + +func TestContainer_GetMultiSigner(t *testing.T) { + +} + +func TestContainer_IsInterfaceNil(t *testing.T) { + +} + +func TestContainer_createMultiSigner(t *testing.T) { + +} + +func TestContainer_createLowLevelSigner(t *testing.T) { + +} + +func TestContainer_getMultiSigHasherFromConfig(t *testing.T) { + +} + +func TestContainer_sortMultiSignerConfig(t *testing.T) { + +} + +// +//func TestCryptoComponentsFactory_GetMultiSigHasherFromConfigInvalidHasherShouldErr(t *testing.T) { +// t.Parallel() +// if testing.Short() { +// t.Skip("this is not a short test") +// } +// +// coreComponents := componentsMock.GetCoreComponents() +// args := componentsMock.GetCryptoArgs(coreComponents) +// args.Config.Consensus.Type = "" +// args.Config.MultisigHasher.Type = "" +// ccf, err := cryptoComp.NewCryptoComponentsFactory(args) +// require.NotNil(t, ccf) +// require.Nil(t, err) +// +// multiSigHasher, err := cryptoComp.GetMultiSigHasherFromConfig() +// require.Nil(t, multiSigHasher) +// require.Equal(t, errErd.ErrMissingMultiHasherConfig, err) +//} +// +//func TestCryptoComponentsFactory_GetMultiSigHasherFromConfigMismatchConsensusTypeMultiSigHasher(t *testing.T) { +// t.Parallel() +// if testing.Short() { +// t.Skip("this is not a short test") +// } +// +// coreComponents := componentsMock.GetCoreComponents() +// args := componentsMock.GetCryptoArgs(coreComponents) +// args.Config.MultisigHasher.Type = "sha256" +// ccf, err := cryptoComp.NewCryptoComponentsFactory(args) +// require.NotNil(t, ccf) +// require.Nil(t, err) +// +// multiSigHasher, err := cryptoComp.GetMultiSigHasherFromConfig() +// require.Nil(t, multiSigHasher) +// require.Equal(t, errErd.ErrMultiSigHasherMissmatch, err) +//} +// +//func TestCryptoComponentsFactory_GetMultiSigHasherFromConfigOK(t *testing.T) { +// t.Parallel() +// if testing.Short() { +// t.Skip("this is not a short test") +// } +// +// coreComponents := componentsMock.GetCoreComponents() +// args := componentsMock.GetCryptoArgs(coreComponents) +// args.Config.Consensus.Type = "bls" +// args.Config.MultisigHasher.Type = "blake2b" +// ccf, err := cryptoComp.NewCryptoComponentsFactory(args) +// require.NotNil(t, ccf) +// require.Nil(t, err) +// +// multiSigHasher, err := cryptoComp.GetMultiSigHasherFromConfig() +// require.Nil(t, err) +// require.NotNil(t, multiSigHasher) +//} diff --git a/integrationTests/multisig/blsMultisig_test.go b/integrationTests/multisig/blsMultisig_test.go index ed7a001ddb8..31cef69fa84 100644 --- a/integrationTests/multisig/blsMultisig_test.go +++ b/integrationTests/multisig/blsMultisig_test.go @@ -1,8 +1,6 @@ package multisig import ( - "bytes" - "errors" "fmt" "testing" @@ -16,123 +14,37 @@ import ( "github.com/stretchr/testify/assert" ) -func createMultiSignersBls( - numOfSigners uint16, +func createKeysAndMultiSignerBls( grSize uint16, hasher hashing.Hasher, suite crypto.Suite, -) ([]string, []crypto.MultiSigner) { +) ([][]byte, [][]byte, crypto.MultiSigner) { kg := signing.NewKeyGenerator(suite) - - var pubKeyBytes []byte - - privKeys := make([]crypto.PrivateKey, grSize) - pubKeys := make([]crypto.PublicKey, grSize) - pubKeysStr := make([]string, grSize) + privKeys := make([][]byte, grSize) + pubKeys := make([][]byte, grSize) for i := uint16(0); i < grSize; i++ { sk, pk := kg.GeneratePair() - privKeys[i] = sk - pubKeys[i] = pk - - pubKeyBytes, _ = pk.ToByteArray() - pubKeysStr[i] = string(pubKeyBytes) + privKeys[i], _ = sk.ToByteArray() + pubKeys[i], _ = pk.ToByteArray() } - - multiSigners := make([]crypto.MultiSigner, numOfSigners) llSigner := &llsig.BlsMultiSigner{Hasher: hasher} - for i := uint16(0); i < numOfSigners; i++ { - multiSigners[i], _ = multisig.NewBLSMultisig(llSigner, pubKeysStr, privKeys[i], kg, i) - } + multiSigner, _ := multisig.NewBLSMultisig(llSigner, kg) - return pubKeysStr, multiSigners + return privKeys, pubKeys, multiSigner } -func createSignaturesShares(numOfSigners uint16, multiSigners []crypto.MultiSigner, message []byte) [][]byte { - sigShares := make([][]byte, numOfSigners) - for i := uint16(0); i < numOfSigners; i++ { - sigShares[i], _ = multiSigners[i].CreateSignatureShare(message, []byte("")) +func createSignaturesShares(privKeys [][]byte, multiSigner crypto.MultiSigner, message []byte) [][]byte { + sigShares := make([][]byte, len(privKeys)) + for i := uint16(0); i < uint16(len(privKeys)); i++ { + sigShares[i], _ = multiSigner.CreateSignatureShare(privKeys[i], message) } return sigShares } -func setSignatureSharesAllSignersBls(multiSigners []crypto.MultiSigner, sigs [][]byte) error { - grSize := uint16(len(multiSigners)) - var err error - - for i := uint16(0); i < grSize; i++ { - for j := uint16(0); j < grSize; j++ { - err = multiSigners[j].StoreSignatureShare(i, sigs[i]) - if err != nil { - return err - } - } - } - - return nil -} - -func verifySigAllSignersBls( - multiSigners []crypto.MultiSigner, - message []byte, - signature []byte, - pubKeys []string, - bitmap []byte, - grSize uint16, -) error { - - var err error - var muSig crypto.MultiSigner - - for i := uint16(0); i < grSize; i++ { - muSig, err = multiSigners[i].Create(pubKeys, i) - if err != nil { - return err - } - - multiSigners[i] = muSig - err = multiSigners[i].SetAggregatedSig(signature) - if err != nil { - return err - } - - err = multiSigners[i].Verify(message, bitmap) - if err != nil { - return err - } - } - - return nil -} - -func aggregateSignatureSharesAllSignersBls(multiSigners []crypto.MultiSigner, bitmap []byte, grSize uint16) ( - signature []byte, - err error, -) { - aggSig, err := multiSigners[0].AggregateSigs(bitmap) - - if err != nil { - return nil, err - } - - for i := uint16(1); i < grSize; i++ { - aggSig2, err1 := multiSigners[i].AggregateSigs(bitmap) - - if err1 != nil { - return nil, err1 - } - - if !bytes.Equal(aggSig, aggSig2) { - return nil, errors.New("aggregated signatures not equal") - } - } - - return aggSig, nil -} - func TestMultiSig_Bls(t *testing.T) { if testing.Short() { t.Skip("this is not a short test") @@ -140,37 +52,24 @@ func TestMultiSig_Bls(t *testing.T) { t.Parallel() - consensusGroupSize := uint16(6) - numOfSigners := uint16(6) + numSigners := uint16(6) message := "message" - - bitmapSize := consensusGroupSize/8 + 1 - // set bitmap to select all members - bitmap := make([]byte, bitmapSize) - byteMask := 0xFF - for i := uint16(0); i < bitmapSize; i++ { - bitmap[i] = byte((((1 << consensusGroupSize) - 1) >> i) & byteMask) - } - hashSize := 16 hasher, _ := blake2b.NewBlake2bWithSize(hashSize) suite := mcl.NewSuiteBLS12() - pubKeysStr, multiSigners := createMultiSignersBls(numOfSigners, consensusGroupSize, hasher, suite) + privKeys, pubKeys, multiSigner := createKeysAndMultiSignerBls(numSigners, hasher, suite) numOfTimesToRepeatTests := 100 for currentIdx := 0; currentIdx < numOfTimesToRepeatTests; currentIdx++ { message = fmt.Sprintf("%s%d", message, currentIdx) - signatures := createSignaturesShares(numOfSigners, multiSigners, []byte(message)) - - err := setSignatureSharesAllSignersBls(multiSigners, signatures) - assert.Nil(t, err) + signatures := createSignaturesShares(privKeys, multiSigner, []byte(message)) - aggSig, err := aggregateSignatureSharesAllSignersBls(multiSigners, bitmap, consensusGroupSize) + aggSig, err := multiSigner.AggregateSigs(pubKeys, signatures) assert.Nil(t, err) assert.NotNil(t, aggSig) - err = verifySigAllSignersBls(multiSigners, []byte(message), aggSig, pubKeysStr, bitmap, consensusGroupSize) + err = multiSigner.VerifyAggregatedSig(pubKeys, []byte(message), aggSig) assert.Nil(t, err) } } From 66a65763b0e99c271bb1f19e0ddae2d611e7199e Mon Sep 17 00:00:00 2001 From: AdoAdoAdo Date: Fri, 22 Jul 2022 16:14:12 +0300 Subject: [PATCH 05/10] factory: fix integration tests --- factory/crypto/cryptoComponentsHandler.go | 7 +++++++ factory/crypto/cryptoComponentsHandler_test.go | 17 +---------------- 2 files changed, 8 insertions(+), 16 deletions(-) diff --git a/factory/crypto/cryptoComponentsHandler.go b/factory/crypto/cryptoComponentsHandler.go index 4cc0c082711..94b192be353 100644 --- a/factory/crypto/cryptoComponentsHandler.go +++ b/factory/crypto/cryptoComponentsHandler.go @@ -198,6 +198,9 @@ func (mcc *managedCryptoComponents) BlockSigner() crypto.SingleSigner { func (mcc *managedCryptoComponents) MultiSignerContainer() cryptoCommon.MultiSignerContainer { mcc.mutCryptoComponents.RLock() defer mcc.mutCryptoComponents.RUnlock() + if mcc.cryptoComponents == nil { + return nil + } return mcc.multiSignerContainer } @@ -216,6 +219,10 @@ func (mcc *managedCryptoComponents) GetMultiSigner(epoch uint32) (crypto.MultiSi mcc.mutCryptoComponents.RLock() defer mcc.mutCryptoComponents.RUnlock() + if mcc.cryptoComponents == nil { + return nil, errors.ErrNilCryptoComponentsHolder + } + if mcc.multiSignerContainer == nil { return nil, errors.ErrNilMultiSignerContainer } diff --git a/factory/crypto/cryptoComponentsHandler_test.go b/factory/crypto/cryptoComponentsHandler_test.go index d9daf557f46..7f5def4da90 100644 --- a/factory/crypto/cryptoComponentsHandler_test.go +++ b/factory/crypto/cryptoComponentsHandler_test.go @@ -71,21 +71,6 @@ func TestManagedCryptoComponents_CheckSubcomponents(t *testing.T) { require.NoError(t, err) } -//func TestManagedCryptoComponents_SetMultiSigner(t *testing.T) { -// t.Parallel() -// if testing.Short() { -// t.Skip("this is not a short test") -// } -// -// managedCryptoComponents := getManagedCryptoComponents(t) -// -// ms := &cryptoMocks.MultisignerMock{} -// err := managedCryptoComponents.SetMultiSigner(ms) -// require.NoError(t, err) -// -// require.Equal(t, managedCryptoComponents.MultiSignerContainer(), ms) -//} - func TestManagedCryptoComponents_Close(t *testing.T) { t.Parallel() if testing.Short() { @@ -98,7 +83,7 @@ func TestManagedCryptoComponents_Close(t *testing.T) { require.NoError(t, err) multiSigner, errGet := managedCryptoComponents.GetMultiSigner(0) require.Nil(t, multiSigner) - require.Equal(t, errors.ErrNilMultiSigner, errGet) + require.Equal(t, errors.ErrNilCryptoComponentsHolder, errGet) } func getManagedCryptoComponents(t *testing.T) factory.CryptoComponentsHandler { From e7a4f5f08bec8818f5723bc84d73e6732fc87665 Mon Sep 17 00:00:00 2001 From: AdoAdoAdo Date: Mon, 25 Jul 2022 15:20:48 +0300 Subject: [PATCH 06/10] factory: add unit tests for multisig container --- config/tomlConfig_test.go | 4 +- consensus/spos/consensusCore.go | 2 +- factory/crypto/cryptoComponents.go | 10 +- factory/crypto/export_test.go | 6 - factory/crypto/multiSignerContainer.go | 22 +- factory/crypto/multiSignerContainer_test.go | 368 +++++++++++++++++--- go.mod | 2 +- go.sum | 4 +- 8 files changed, 333 insertions(+), 85 deletions(-) diff --git a/config/tomlConfig_test.go b/config/tomlConfig_test.go index d40eb8631ad..f69812168b5 100644 --- a/config/tomlConfig_test.go +++ b/config/tomlConfig_test.go @@ -672,7 +672,7 @@ func TestEnableEpochConfig(t *testing.T) { ] BLSMultiSignerEnableEpoch = [ - {EnableEpoch = 0, Type = "non-KOSK"}, + {EnableEpoch = 0, Type = "no-KOSK"}, {EnableEpoch = 3, Type = "KOSK"} ] @@ -756,7 +756,7 @@ func TestEnableEpochConfig(t *testing.T) { BLSMultiSignerEnableEpoch: []MultiSignerConfig{ { EnableEpoch: 0, - Type: "non-KOSK", + Type: "no-KOSK", }, { EnableEpoch: 3, diff --git a/consensus/spos/consensusCore.go b/consensus/spos/consensusCore.go index e08c9724133..d661de836d2 100644 --- a/consensus/spos/consensusCore.go +++ b/consensus/spos/consensusCore.go @@ -141,7 +141,7 @@ func (cc *ConsensusCore) Marshalizer() marshal.Marshalizer { return cc.marshalizer } -// MultiSignerContainer gets the MultiSigner stored in the ConsensusCore +// MultiSignerContainer gets the MultiSignerContainer stored in the ConsensusCore func (cc *ConsensusCore) MultiSignerContainer() cryptoCommon.MultiSignerContainer { return cc.multiSignerContainer } diff --git a/factory/crypto/cryptoComponents.go b/factory/crypto/cryptoComponents.go index b82222c7b2b..0f4b2b14889 100644 --- a/factory/crypto/cryptoComponents.go +++ b/factory/crypto/cryptoComponents.go @@ -199,11 +199,11 @@ func (ccf *cryptoComponentsFactory) createMultiSignerContainer( ) (cryptoCommon.MultiSignerContainer, error) { args := MultiSigArgs{ - multiSigHasherType: ccf.config.MultisigHasher.Type, - cryptoParams: cp, - blSignKeyGen: blSignKeyGen, - consensusType: ccf.consensusType, - importModeNoSigCheck: importModeNoSigCheck, + MultiSigHasherType: ccf.config.MultisigHasher.Type, + CryptoParams: cp, + BlSignKeyGen: blSignKeyGen, + ConsensusType: ccf.consensusType, + ImportModeNoSigCheck: importModeNoSigCheck, } return NewMultiSignerContainer(args, ccf.enableEpochs.BLSMultiSignerEnableEpoch) } diff --git a/factory/crypto/export_test.go b/factory/crypto/export_test.go index 6efc1e53c45..f891e169af2 100644 --- a/factory/crypto/export_test.go +++ b/factory/crypto/export_test.go @@ -1,7 +1,6 @@ package crypto import ( - "github.com/ElrondNetwork/elrond-go-core/hashing" crypto "github.com/ElrondNetwork/elrond-go-crypto" cryptoCommon "github.com/ElrondNetwork/elrond-go/common/crypto" ) @@ -16,11 +15,6 @@ func (ccf *cryptoComponentsFactory) CreateSingleSigner(importModeNoSigCheck bool return ccf.createSingleSigner(importModeNoSigCheck) } -// GetMultiSigHasherFromConfig - -func GetMultiSigHasherFromConfig(args MultiSigArgs) (hashing.Hasher, error) { - return getMultiSigHasherFromConfig(args) -} - // CreateDummyCryptoParams func (ccf *cryptoComponentsFactory) CreateDummyCryptoParams() *cryptoParams { return &cryptoParams{} diff --git a/factory/crypto/multiSignerContainer.go b/factory/crypto/multiSignerContainer.go index d4b44a05f2d..1bc9e474878 100644 --- a/factory/crypto/multiSignerContainer.go +++ b/factory/crypto/multiSignerContainer.go @@ -34,11 +34,11 @@ type container struct { // MultiSigArgs holds the arguments for creating the multiSignerContainer container type MultiSigArgs struct { - multiSigHasherType string - cryptoParams *cryptoParams - blSignKeyGen crypto.KeyGenerator - consensusType string - importModeNoSigCheck bool + MultiSigHasherType string + CryptoParams *cryptoParams + BlSignKeyGen crypto.KeyGenerator + ConsensusType string + ImportModeNoSigCheck bool } // NewMultiSignerContainer creates the multiSignerContainer container @@ -90,12 +90,12 @@ func (c *container) IsInterfaceNil() bool { } func createMultiSigner(multiSigType string, args MultiSigArgs) (crypto.MultiSigner, error) { - if args.importModeNoSigCheck { + if args.ImportModeNoSigCheck { log.Warn("using disabled multi signer because the node is running in import-db 'turbo mode'") return &disabledMultiSig.DisabledMultiSig{}, nil } - switch args.consensusType { + switch args.ConsensusType { case consensus.BlsConsensusType: hasher, err := getMultiSigHasherFromConfig(args) if err != nil { @@ -105,7 +105,7 @@ func createMultiSigner(multiSigType string, args MultiSigArgs) (crypto.MultiSign if err != nil { return nil, err } - return multisig.NewBLSMultisig(blsSigner, args.blSignKeyGen) + return multisig.NewBLSMultisig(blsSigner, args.BlSignKeyGen) case disabledSigChecking: log.Warn("using disabled multi signer") return &disabledMultiSig.DisabledMultiSig{}, nil @@ -130,15 +130,15 @@ func createLowLevelSigner(multiSigType string, hasher hashing.Hasher) (crypto.Lo } func getMultiSigHasherFromConfig(args MultiSigArgs) (hashing.Hasher, error) { - if args.consensusType == consensus.BlsConsensusType && args.multiSigHasherType != "blake2b" { + if args.ConsensusType == consensus.BlsConsensusType && args.MultiSigHasherType != "blake2b" { return nil, errors.ErrMultiSigHasherMissmatch } - switch args.multiSigHasherType { + switch args.MultiSigHasherType { case "sha256": return sha256.NewSha256(), nil case "blake2b": - if args.consensusType == consensus.BlsConsensusType { + if args.ConsensusType == consensus.BlsConsensusType { return blake2b.NewBlake2bWithSize(mclMultiSig.HasherOutputSize) } return blake2b.NewBlake2b(), nil diff --git a/factory/crypto/multiSignerContainer_test.go b/factory/crypto/multiSignerContainer_test.go index 98fe6642fe0..a98829a4590 100644 --- a/factory/crypto/multiSignerContainer_test.go +++ b/factory/crypto/multiSignerContainer_test.go @@ -1,90 +1,344 @@ -package crypto_test +package crypto import ( + "math/rand" "testing" + + "github.com/ElrondNetwork/elrond-go-core/core/check" + disabledMultiSig "github.com/ElrondNetwork/elrond-go-crypto/signing/disabled/multisig" + mclMultiSig "github.com/ElrondNetwork/elrond-go-crypto/signing/mcl/multisig" + "github.com/ElrondNetwork/elrond-go/config" + "github.com/ElrondNetwork/elrond-go/consensus" + "github.com/ElrondNetwork/elrond-go/errors" + "github.com/ElrondNetwork/elrond-go/testscommon/cryptoMocks" + "github.com/ElrondNetwork/elrond-go/testscommon/hashingMocks" + "github.com/stretchr/testify/assert" + "github.com/stretchr/testify/require" ) func Test_NewMultiSignerContainer(t *testing.T) { + t.Parallel() + + args := createDefaultMultiSignerArgs() + multiSigConfig := createDefaultMultiSignerConfig() + + t.Run("nil multiSigner config should err", func(t *testing.T) { + multiSigContainer, err := NewMultiSignerContainer(args, nil) + + require.Nil(t, multiSigContainer) + require.Equal(t, errors.ErrMissingMultiSignerConfig, err) + }) + t.Run("missing epoch 0 config should err", func(t *testing.T) { + multiSigConfigClone := append([]config.MultiSignerConfig{}, multiSigConfig...) + multiSigConfigClone[0].EnableEpoch = 1 + multiSigContainer, err := NewMultiSignerContainer(args, multiSigConfigClone) + require.Nil(t, multiSigContainer) + require.Equal(t, errors.ErrNilMultiSigner, err) + }) + t.Run("invalid multiSigner type should err", func(t *testing.T) { + multiSigConfigClone := append([]config.MultiSignerConfig{}, multiSigConfig...) + multiSigConfigClone[1].Type = "invalid type" + multiSigContainer, err := NewMultiSignerContainer(args, multiSigConfigClone) + + require.Nil(t, multiSigContainer) + require.Equal(t, errors.ErrSignerNotSupported, err) + }) + t.Run("valid params", func(t *testing.T) { + multiSigContainer, err := NewMultiSignerContainer(args, multiSigConfig) + + require.Nil(t, err) + require.NotNil(t, multiSigContainer) + }) } func TestContainer_GetMultiSigner(t *testing.T) { + t.Parallel() + + args := createDefaultMultiSignerArgs() + multiSigConfig := createDefaultMultiSignerConfig() + t.Run("missing epoch config should err (can only happen if epoch 0 is missing)", func(t *testing.T) { + multiSigContainer, _ := NewMultiSignerContainer(args, multiSigConfig) + multiSigContainer.multiSigners[0].epoch = 1 + + multiSigner, err := multiSigContainer.GetMultiSigner(0) + require.Nil(t, multiSigner) + require.Equal(t, errors.ErrMissingMultiSignerConfig, err) + }) + t.Run("get multi signer OK", func(t *testing.T) { + multiSigContainer, _ := NewMultiSignerContainer(args, multiSigConfig) + + for i := uint32(0); i < 10; i++ { + multiSigner, err := multiSigContainer.GetMultiSigner(i) + require.Nil(t, err) + require.Equal(t, multiSigContainer.multiSigners[0].multiSigner, multiSigner) + } + for i := uint32(10); i < 30; i++ { + multiSigner, err := multiSigContainer.GetMultiSigner(i) + require.Nil(t, err) + require.Equal(t, multiSigContainer.multiSigners[1].multiSigner, multiSigner) + } + }) } func TestContainer_IsInterfaceNil(t *testing.T) { + t.Parallel() + + var msc *container + assert.True(t, check.IfNil(msc)) + + args := createDefaultMultiSignerArgs() + multiSigConfig := createDefaultMultiSignerConfig() + msc, _ = NewMultiSignerContainer(args, multiSigConfig) + assert.False(t, check.IfNil(msc)) } func TestContainer_createMultiSigner(t *testing.T) { + t.Parallel() + t.Run("create disabled multi signer", func(t *testing.T) { + args := createDefaultMultiSignerArgs() + args.ImportModeNoSigCheck = true + multiSigType := "KOSK" + multiSigner, err := createMultiSigner(multiSigType, args) + require.Nil(t, err) + _, ok := multiSigner.(*disabledMultiSig.DisabledMultiSig) + require.True(t, ok) + }) + t.Run("invalid consensus config", func(t *testing.T) { + args := createDefaultMultiSignerArgs() + args.ConsensusType = "invalid" + multiSigType := "KOSK" + multiSigner, err := createMultiSigner(multiSigType, args) + require.Nil(t, multiSigner) + require.Equal(t, errors.ErrInvalidConsensusConfig, err) + }) + t.Run("bls consensus type invalid hasher config", func(t *testing.T) { + args := createDefaultMultiSignerArgs() + args.ConsensusType = consensus.BlsConsensusType + args.MultiSigHasherType = "sha256" + multiSigType := "KOSK" + multiSigner, err := createMultiSigner(multiSigType, args) + require.Nil(t, multiSigner) + require.Equal(t, errors.ErrMultiSigHasherMissmatch, err) + }) + t.Run("bls consensus type signer not supported", func(t *testing.T) { + args := createDefaultMultiSignerArgs() + args.ConsensusType = consensus.BlsConsensusType + args.MultiSigHasherType = "blake2b" + multiSigType := "not supported" + multiSigner, err := createMultiSigner(multiSigType, args) + require.Nil(t, multiSigner) + require.Equal(t, errors.ErrSignerNotSupported, err) + }) + t.Run("bls consensus type KOSK OK", func(t *testing.T) { + args := createDefaultMultiSignerArgs() + args.ConsensusType = consensus.BlsConsensusType + args.MultiSigHasherType = "blake2b" + multiSigType := blsKOSK + multiSigner, err := createMultiSigner(multiSigType, args) + require.Nil(t, err) + require.NotNil(t, multiSigner) + }) + t.Run("bls consensus type no-KOSK OK", func(t *testing.T) { + args := createDefaultMultiSignerArgs() + args.ConsensusType = consensus.BlsConsensusType + args.MultiSigHasherType = "blake2b" + multiSigType := blsNoKOSK + multiSigner, err := createMultiSigner(multiSigType, args) + require.Nil(t, err) + require.NotNil(t, multiSigner) + }) + t.Run("disabledSigChecking", func(t *testing.T) { + args := createDefaultMultiSignerArgs() + args.ConsensusType = disabledSigChecking + multiSigType := blsNoKOSK + multiSigner, err := createMultiSigner(multiSigType, args) + require.Nil(t, err) + require.NotNil(t, multiSigner) + + _, ok := multiSigner.(*disabledMultiSig.DisabledMultiSig) + require.True(t, ok) + }) } func TestContainer_createLowLevelSigner(t *testing.T) { + t.Parallel() + hasher := &hashingMocks.HasherMock{} + t.Run("nil hasher should err", func(t *testing.T) { + llSig, err := createLowLevelSigner(blsKOSK, nil) + require.Nil(t, llSig) + require.Equal(t, errors.ErrNilHasher, err) + }) + t.Run("not supported multiSig type should err", func(t *testing.T) { + llSig, err := createLowLevelSigner("not supported", hasher) + require.Nil(t, llSig) + require.Equal(t, errors.ErrSignerNotSupported, err) + }) + t.Run("multiSig of type no KOSK", func(t *testing.T) { + llSig, err := createLowLevelSigner(blsNoKOSK, hasher) + require.Nil(t, err) + _, ok := llSig.(*mclMultiSig.BlsMultiSigner) + require.True(t, ok) + }) + t.Run("multiSig of type KOSK", func(t *testing.T) { + llSig, err := createLowLevelSigner(blsKOSK, hasher) + require.Nil(t, err) + _, ok := llSig.(*mclMultiSig.BlsMultiSignerKOSK) + require.True(t, ok) + }) } func TestContainer_getMultiSigHasherFromConfig(t *testing.T) { + t.Parallel() + t.Run("mismatch config consensus type and hasher type", func(t *testing.T) { + args := createDefaultMultiSignerArgs() + args.ConsensusType = consensus.BlsConsensusType + args.MultiSigHasherType = "sha256" + hasher, err := getMultiSigHasherFromConfig(args) + require.Nil(t, hasher) + require.Equal(t, errors.ErrMultiSigHasherMissmatch, err) + }) + t.Run("sha256 config", func(t *testing.T) { + args := createDefaultMultiSignerArgs() + args.ConsensusType = "dummy config" + args.MultiSigHasherType = "sha256" + hasher, err := getMultiSigHasherFromConfig(args) + require.Nil(t, err) + require.NotNil(t, hasher) + }) + t.Run("invalid hasher config", func(t *testing.T) { + args := createDefaultMultiSignerArgs() + args.ConsensusType = "dummy config" + args.MultiSigHasherType = "unknown" + hasher, err := getMultiSigHasherFromConfig(args) + require.Nil(t, hasher) + require.Equal(t, errors.ErrMissingMultiHasherConfig, err) + }) + t.Run("blake2b config and bls consensus", func(t *testing.T) { + args := createDefaultMultiSignerArgs() + args.ConsensusType = consensus.BlsConsensusType + args.MultiSigHasherType = "blake2b" + hasher, err := getMultiSigHasherFromConfig(args) + require.Nil(t, err) + require.NotNil(t, hasher) + }) + t.Run("blake2b config and non-bls consensus", func(t *testing.T) { + args := createDefaultMultiSignerArgs() + args.ConsensusType = "dummy config" + args.MultiSigHasherType = "blake2b" + hasher, err := getMultiSigHasherFromConfig(args) + require.Nil(t, err) + require.NotNil(t, hasher) + }) } func TestContainer_sortMultiSignerConfig(t *testing.T) { + multiSignersOrderedConfig := []config.MultiSignerConfig{ + { + EnableEpoch: 2, + Type: "KOSK", + }, + { + EnableEpoch: 10, + Type: "no-KOSK", + }, + { + EnableEpoch: 100, + Type: "BN", + }, + { + EnableEpoch: 200, + Type: "DUMMY", + }, + } + + for i := 0; i < 20; i++ { + shuffledConfig := append([]config.MultiSignerConfig{}, multiSignersOrderedConfig...) + rand.Shuffle(len(shuffledConfig), func(i, j int) { + shuffledConfig[i], shuffledConfig[j] = shuffledConfig[j], shuffledConfig[i] + }) + sortedConfig := sortMultiSignerConfig(shuffledConfig) + require.Equal(t, multiSignersOrderedConfig, sortedConfig) + } +} +func Test_getMultiSigHasherFromConfigInvalidHasherShouldErr(t *testing.T) { + t.Parallel() + if testing.Short() { + t.Skip("this is not a short test") + } + + args := createDefaultMultiSignerArgs() + args.ConsensusType = "" + args.MultiSigHasherType = "" + + multiSigHasher, err := getMultiSigHasherFromConfig(args) + require.Nil(t, multiSigHasher) + require.Equal(t, errors.ErrMissingMultiHasherConfig, err) +} + +func Test_getMultiSigHasherFromConfigMismatchConsensusTypeMultiSigHasher(t *testing.T) { + t.Parallel() + if testing.Short() { + t.Skip("this is not a short test") + } + + args := createDefaultMultiSignerArgs() + args.MultiSigHasherType = "sha256" + + multiSigHasher, err := getMultiSigHasherFromConfig(args) + require.Nil(t, multiSigHasher) + require.Equal(t, errors.ErrMultiSigHasherMissmatch, err) +} + +func Test_getMultiSigHasherFromConfigOK(t *testing.T) { + t.Parallel() + if testing.Short() { + t.Skip("this is not a short test") + } + + args := createDefaultMultiSignerArgs() + args.ConsensusType = "bls" + args.MultiSigHasherType = "blake2b" + + multiSigHasher, err := getMultiSigHasherFromConfig(args) + require.Nil(t, err) + require.NotNil(t, multiSigHasher) } -// -//func TestCryptoComponentsFactory_GetMultiSigHasherFromConfigInvalidHasherShouldErr(t *testing.T) { -// t.Parallel() -// if testing.Short() { -// t.Skip("this is not a short test") -// } -// -// coreComponents := componentsMock.GetCoreComponents() -// args := componentsMock.GetCryptoArgs(coreComponents) -// args.Config.Consensus.Type = "" -// args.Config.MultisigHasher.Type = "" -// ccf, err := cryptoComp.NewCryptoComponentsFactory(args) -// require.NotNil(t, ccf) -// require.Nil(t, err) -// -// multiSigHasher, err := cryptoComp.GetMultiSigHasherFromConfig() -// require.Nil(t, multiSigHasher) -// require.Equal(t, errErd.ErrMissingMultiHasherConfig, err) -//} -// -//func TestCryptoComponentsFactory_GetMultiSigHasherFromConfigMismatchConsensusTypeMultiSigHasher(t *testing.T) { -// t.Parallel() -// if testing.Short() { -// t.Skip("this is not a short test") -// } -// -// coreComponents := componentsMock.GetCoreComponents() -// args := componentsMock.GetCryptoArgs(coreComponents) -// args.Config.MultisigHasher.Type = "sha256" -// ccf, err := cryptoComp.NewCryptoComponentsFactory(args) -// require.NotNil(t, ccf) -// require.Nil(t, err) -// -// multiSigHasher, err := cryptoComp.GetMultiSigHasherFromConfig() -// require.Nil(t, multiSigHasher) -// require.Equal(t, errErd.ErrMultiSigHasherMissmatch, err) -//} -// -//func TestCryptoComponentsFactory_GetMultiSigHasherFromConfigOK(t *testing.T) { -// t.Parallel() -// if testing.Short() { -// t.Skip("this is not a short test") -// } -// -// coreComponents := componentsMock.GetCoreComponents() -// args := componentsMock.GetCryptoArgs(coreComponents) -// args.Config.Consensus.Type = "bls" -// args.Config.MultisigHasher.Type = "blake2b" -// ccf, err := cryptoComp.NewCryptoComponentsFactory(args) -// require.NotNil(t, ccf) -// require.Nil(t, err) -// -// multiSigHasher, err := cryptoComp.GetMultiSigHasherFromConfig() -// require.Nil(t, err) -// require.NotNil(t, multiSigHasher) -//} +func createDefaultMultiSignerArgs() MultiSigArgs { + publicKey := "public key" + privateKey := "private key" + + return MultiSigArgs{ + MultiSigHasherType: "blake2b", + CryptoParams: &cryptoParams{ + publicKey: &cryptoMocks.PublicKeyStub{}, + privateKey: &cryptoMocks.PrivateKeyStub{}, + publicKeyString: publicKey, + publicKeyBytes: []byte(publicKey), + privateKeyBytes: []byte(privateKey), + }, + BlSignKeyGen: &cryptoMocks.KeyGenStub{}, + ConsensusType: "bls", + ImportModeNoSigCheck: false, + } +} + +func createDefaultMultiSignerConfig() []config.MultiSignerConfig { + return []config.MultiSignerConfig{ + { + EnableEpoch: 0, + Type: "no-KOSK", + }, + { + EnableEpoch: 10, + Type: "KOSK", + }, + } +} diff --git a/go.mod b/go.mod index 8b3822f11c5..be1758ad536 100644 --- a/go.mod +++ b/go.mod @@ -10,7 +10,7 @@ require ( github.com/ElrondNetwork/covalent-indexer-go v1.0.6 github.com/ElrondNetwork/elastic-indexer-go v1.2.34-partial-execution github.com/ElrondNetwork/elrond-go-core v1.1.16-0.20220708085217-ccc0c5ac9076 - github.com/ElrondNetwork/elrond-go-crypto v1.1.1-0.20220721140234-4e1d265e997e + github.com/ElrondNetwork/elrond-go-crypto v1.1.1-0.20220725093518-7a5126e0f2e3 github.com/ElrondNetwork/elrond-go-logger v1.0.7 github.com/ElrondNetwork/elrond-vm-common v1.3.13 github.com/ElrondNetwork/go-libp2p-pubsub v0.6.1-rc1 diff --git a/go.sum b/go.sum index e3bbc911891..cdcfb5a0a8e 100644 --- a/go.sum +++ b/go.sum @@ -64,8 +64,8 @@ github.com/ElrondNetwork/elrond-go-core v1.1.16-0.20220414130405-e3cc29bc7711/go github.com/ElrondNetwork/elrond-go-core v1.1.16-0.20220708085217-ccc0c5ac9076 h1:/tNU9ydW91/rZAFTDXSDhLSPEcBs9w6+g+4NF6uqMeo= github.com/ElrondNetwork/elrond-go-core v1.1.16-0.20220708085217-ccc0c5ac9076/go.mod h1:Yz8JK5sGBctw7+gU8j2mZHbzQ09Ek4XHJ4Uinq1N6nM= github.com/ElrondNetwork/elrond-go-crypto v1.0.0/go.mod h1:DGiR7/j1xv729Xg8SsjYaUzWXL5svMd44REXjWS/gAc= -github.com/ElrondNetwork/elrond-go-crypto v1.1.1-0.20220721140234-4e1d265e997e h1:rCVoKQCCJGTLDFhGJyw+xzahYs/64OBCFVD3zYKOngo= -github.com/ElrondNetwork/elrond-go-crypto v1.1.1-0.20220721140234-4e1d265e997e/go.mod h1:uunsvweBrrhVojL8uiQSaTPsl3YIQ9iBqtYGM6xs4s0= +github.com/ElrondNetwork/elrond-go-crypto v1.1.1-0.20220725093518-7a5126e0f2e3 h1:xzsgiXav4lRJjLfs05B90m2cgeFHjLyhGox8vXBZG9A= +github.com/ElrondNetwork/elrond-go-crypto v1.1.1-0.20220725093518-7a5126e0f2e3/go.mod h1:uunsvweBrrhVojL8uiQSaTPsl3YIQ9iBqtYGM6xs4s0= github.com/ElrondNetwork/elrond-go-logger v1.0.4/go.mod h1:e5D+c97lKUfFdAzFX7rrI2Igl/z4Y0RkKYKWyzprTGk= github.com/ElrondNetwork/elrond-go-logger v1.0.5/go.mod h1:cBfgx0ST/CJx8jrxJSC5aiSrvkGzcnF7sK06RD8mFxQ= github.com/ElrondNetwork/elrond-go-logger v1.0.7 h1:Ldl1rVS0RGKc1IsW8jIaGCb6Zwei04gsMvyjL05X6mE= From 7c5aa281802ee4ab4f9482bb71211d0eb3605698 Mon Sep 17 00:00:00 2001 From: AdoAdoAdo Date: Tue, 26 Jul 2022 11:54:30 +0300 Subject: [PATCH 07/10] factory: removed from argument list unnecessary crypto params, fixed comments --- factory/crypto/cryptoComponents.go | 4 +--- factory/crypto/cryptoComponentsHandler.go | 2 +- factory/crypto/cryptoComponents_test.go | 6 ++---- factory/crypto/export_test.go | 3 +-- factory/crypto/multiSignerContainer.go | 1 - factory/crypto/multiSignerContainer_test.go | 12 +----------- scripts/testnet/variables.sh | 6 +++--- 7 files changed, 9 insertions(+), 25 deletions(-) diff --git a/factory/crypto/cryptoComponents.go b/factory/crypto/cryptoComponents.go index 0f4b2b14889..e2bfd98150f 100644 --- a/factory/crypto/cryptoComponents.go +++ b/factory/crypto/cryptoComponents.go @@ -132,7 +132,7 @@ func (ccf *cryptoComponentsFactory) Create() (*cryptoComponents, error) { return nil, err } - multiSigner, err := ccf.createMultiSignerContainer(cp, blockSignKeyGen, ccf.importModeNoSigCheck) + multiSigner, err := ccf.createMultiSignerContainer(blockSignKeyGen, ccf.importModeNoSigCheck) if err != nil { return nil, err } @@ -193,14 +193,12 @@ func (ccf *cryptoComponentsFactory) createSingleSigner(importModeNoSigCheck bool } func (ccf *cryptoComponentsFactory) createMultiSignerContainer( - cp *cryptoParams, blSignKeyGen crypto.KeyGenerator, importModeNoSigCheck bool, ) (cryptoCommon.MultiSignerContainer, error) { args := MultiSigArgs{ MultiSigHasherType: ccf.config.MultisigHasher.Type, - CryptoParams: cp, BlSignKeyGen: blSignKeyGen, ConsensusType: ccf.consensusType, ImportModeNoSigCheck: importModeNoSigCheck, diff --git a/factory/crypto/cryptoComponentsHandler.go b/factory/crypto/cryptoComponentsHandler.go index 94b192be353..91e8a867898 100644 --- a/factory/crypto/cryptoComponentsHandler.go +++ b/factory/crypto/cryptoComponentsHandler.go @@ -194,7 +194,7 @@ func (mcc *managedCryptoComponents) BlockSigner() crypto.SingleSigner { return mcc.cryptoComponents.blockSingleSigner } -// MultiSignerContainer - +// MultiSignerContainer returns the multiSigner container holding the multiSigner versions func (mcc *managedCryptoComponents) MultiSignerContainer() cryptoCommon.MultiSignerContainer { mcc.mutCryptoComponents.RLock() defer mcc.mutCryptoComponents.RUnlock() diff --git a/factory/crypto/cryptoComponents_test.go b/factory/crypto/cryptoComponents_test.go index 78c7b61c86c..5453469f275 100644 --- a/factory/crypto/cryptoComponents_test.go +++ b/factory/crypto/cryptoComponents_test.go @@ -218,8 +218,7 @@ func TestCryptoComponentsFactory_CreateMultiSignerInvalidConsensusTypeShouldErr( require.NotNil(t, ccf) require.Nil(t, err) - cp := ccf.CreateDummyCryptoParams() - multiSigner, err := ccf.CreateMultiSignerContainer(cp, &mock.KeyGenMock{}, false) + multiSigner, err := ccf.CreateMultiSignerContainer(&mock.KeyGenMock{}, false) require.Nil(t, multiSigner) require.Equal(t, errErd.ErrInvalidConsensusConfig, err) } @@ -238,9 +237,8 @@ func TestCryptoComponentsFactory_CreateMultiSignerOK(t *testing.T) { suite, _ := ccf.GetSuite() blockSignKeyGen := signing.NewKeyGenerator(suite) - cp, _ := ccf.CreateCryptoParams(blockSignKeyGen) - multiSigner, err := ccf.CreateMultiSignerContainer(cp, blockSignKeyGen, false) + multiSigner, err := ccf.CreateMultiSignerContainer(blockSignKeyGen, false) require.Nil(t, err) require.NotNil(t, multiSigner) } diff --git a/factory/crypto/export_test.go b/factory/crypto/export_test.go index f891e169af2..9e006c825f3 100644 --- a/factory/crypto/export_test.go +++ b/factory/crypto/export_test.go @@ -27,11 +27,10 @@ func (ccf *cryptoComponentsFactory) CreateCryptoParams(blockSignKeyGen crypto.Ke // CreateMultiSignerContainer - func (ccf *cryptoComponentsFactory) CreateMultiSignerContainer( - cp *cryptoParams, blSignKeyGen crypto.KeyGenerator, importModeNoSigCheck bool, ) (cryptoCommon.MultiSignerContainer, error) { - return ccf.createMultiSignerContainer(cp, blSignKeyGen, importModeNoSigCheck) + return ccf.createMultiSignerContainer(blSignKeyGen, importModeNoSigCheck) } // GetSuite - diff --git a/factory/crypto/multiSignerContainer.go b/factory/crypto/multiSignerContainer.go index 1bc9e474878..d6498e47afd 100644 --- a/factory/crypto/multiSignerContainer.go +++ b/factory/crypto/multiSignerContainer.go @@ -35,7 +35,6 @@ type container struct { // MultiSigArgs holds the arguments for creating the multiSignerContainer container type MultiSigArgs struct { MultiSigHasherType string - CryptoParams *cryptoParams BlSignKeyGen crypto.KeyGenerator ConsensusType string ImportModeNoSigCheck bool diff --git a/factory/crypto/multiSignerContainer_test.go b/factory/crypto/multiSignerContainer_test.go index a98829a4590..66dbfba1244 100644 --- a/factory/crypto/multiSignerContainer_test.go +++ b/factory/crypto/multiSignerContainer_test.go @@ -312,18 +312,8 @@ func Test_getMultiSigHasherFromConfigOK(t *testing.T) { } func createDefaultMultiSignerArgs() MultiSigArgs { - publicKey := "public key" - privateKey := "private key" - return MultiSigArgs{ - MultiSigHasherType: "blake2b", - CryptoParams: &cryptoParams{ - publicKey: &cryptoMocks.PublicKeyStub{}, - privateKey: &cryptoMocks.PrivateKeyStub{}, - publicKeyString: publicKey, - publicKeyBytes: []byte(publicKey), - privateKeyBytes: []byte(privateKey), - }, + MultiSigHasherType: "blake2b", BlSignKeyGen: &cryptoMocks.KeyGenStub{}, ConsensusType: "bls", ImportModeNoSigCheck: false, diff --git a/scripts/testnet/variables.sh b/scripts/testnet/variables.sh index 44ec24b8aed..f9d836c2afa 100644 --- a/scripts/testnet/variables.sh +++ b/scripts/testnet/variables.sh @@ -53,12 +53,12 @@ export OBSERVERS_ANTIFLOOD_DISABLE=0 # Shard structure export SHARDCOUNT=2 -export SHARD_VALIDATORCOUNT=1 +export SHARD_VALIDATORCOUNT=3 export SHARD_OBSERVERCOUNT=1 -export SHARD_CONSENSUS_SIZE=1 +export SHARD_CONSENSUS_SIZE=3 # Metashard structure -export META_VALIDATORCOUNT=1 +export META_VALIDATORCOUNT=3 export META_OBSERVERCOUNT=1 export META_CONSENSUS_SIZE=$META_VALIDATORCOUNT From a2f8e2cfd999a32edd8e7984a5df03af87d90646 Mon Sep 17 00:00:00 2001 From: AdoAdoAdo Date: Tue, 26 Jul 2022 15:09:26 +0300 Subject: [PATCH 08/10] factory: update comments --- factory/crypto/cryptoComponentsHandler.go | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/factory/crypto/cryptoComponentsHandler.go b/factory/crypto/cryptoComponentsHandler.go index 91e8a867898..34be4bad213 100644 --- a/factory/crypto/cryptoComponentsHandler.go +++ b/factory/crypto/cryptoComponentsHandler.go @@ -205,7 +205,7 @@ func (mcc *managedCryptoComponents) MultiSignerContainer() cryptoCommon.MultiSig return mcc.multiSignerContainer } -// SetMultiSignerContainer - +// SetMultiSignerContainer sets the multiSigner container in the crypto components func (mcc *managedCryptoComponents) SetMultiSignerContainer(ms cryptoCommon.MultiSignerContainer) error { mcc.mutCryptoComponents.Lock() mcc.multiSignerContainer = ms @@ -214,7 +214,7 @@ func (mcc *managedCryptoComponents) SetMultiSignerContainer(ms cryptoCommon.Mult return nil } -// GetMultiSigner - +// GetMultiSigner returns the multiSigner configured in the multiSigner container for the given epoch func (mcc *managedCryptoComponents) GetMultiSigner(epoch uint32) (crypto.MultiSigner, error) { mcc.mutCryptoComponents.RLock() defer mcc.mutCryptoComponents.RUnlock() From bb6e447e4f20d9597a6660279bc224776a381438 Mon Sep 17 00:00:00 2001 From: ssd04 Date: Thu, 28 Jul 2022 17:19:28 +0300 Subject: [PATCH 09/10] fixes after review: nil checks and errors updates --- consensus/spos/bls/subroundSignature.go | 4 ++-- errors/errors.go | 3 +++ factory/crypto/cryptoComponentsHandler.go | 4 ++-- factory/crypto/multiSignerContainer.go | 2 +- factory/crypto/multiSignerContainer_test.go | 2 +- 5 files changed, 9 insertions(+), 6 deletions(-) diff --git a/consensus/spos/bls/subroundSignature.go b/consensus/spos/bls/subroundSignature.go index 44fa9c3684a..3563771734a 100644 --- a/consensus/spos/bls/subroundSignature.go +++ b/consensus/spos/bls/subroundSignature.go @@ -68,7 +68,7 @@ func (sr *subroundSignature) doSignatureJob(_ context.Context) bool { if !sr.CanDoSubroundJob(sr.Current()) { return false } - if sr.Header == nil { + if check.IfNil(sr.Header) { log.Error("doSignatureJob", "error", spos.ErrNilHeader) return false } @@ -172,7 +172,7 @@ func (sr *subroundSignature) receivedSignature(_ context.Context, cnsDta *consen return false } - if sr.Header == nil { + if check.IfNil(sr.Header) { log.Error("receivedSignature", "error", spos.ErrNilHeader) return false } diff --git a/errors/errors.go b/errors/errors.go index d21811d4ca0..582b28c7378 100644 --- a/errors/errors.go +++ b/errors/errors.go @@ -485,6 +485,9 @@ var ErrSignerNotSupported = errors.New("signer not supported") // ErrMissingMultiSignerConfig signals that the multisigner config is missing var ErrMissingMultiSignerConfig = errors.New("multisigner configuration missing") +// ErrMissingEpochZeroMultiSignerConfig signals that the multisigner config for epoch zero is missing +var ErrMissingEpochZeroMultiSignerConfig = errors.New("multisigner configuration missing for epoch zero") + // ErrNilMultiSignerContainer signals that the multisigner container is nil var ErrNilMultiSignerContainer = errors.New("multisigner container is nil") diff --git a/factory/crypto/cryptoComponentsHandler.go b/factory/crypto/cryptoComponentsHandler.go index 34be4bad213..2b2c5f4eb04 100644 --- a/factory/crypto/cryptoComponentsHandler.go +++ b/factory/crypto/cryptoComponentsHandler.go @@ -5,7 +5,7 @@ import ( "sync" "github.com/ElrondNetwork/elrond-go-core/core/check" - "github.com/ElrondNetwork/elrond-go-crypto" + crypto "github.com/ElrondNetwork/elrond-go-crypto" cryptoCommon "github.com/ElrondNetwork/elrond-go/common/crypto" "github.com/ElrondNetwork/elrond-go/errors" "github.com/ElrondNetwork/elrond-go/factory" @@ -202,7 +202,7 @@ func (mcc *managedCryptoComponents) MultiSignerContainer() cryptoCommon.MultiSig return nil } - return mcc.multiSignerContainer + return mcc.cryptoComponents.multiSignerContainer } // SetMultiSignerContainer sets the multiSigner container in the crypto components diff --git a/factory/crypto/multiSignerContainer.go b/factory/crypto/multiSignerContainer.go index d6498e47afd..321658f8326 100644 --- a/factory/crypto/multiSignerContainer.go +++ b/factory/crypto/multiSignerContainer.go @@ -52,7 +52,7 @@ func NewMultiSignerContainer(args MultiSigArgs, multiSignerConfig []config.Multi sortedMultiSignerConfig := sortMultiSignerConfig(multiSignerConfig) if sortedMultiSignerConfig[0].EnableEpoch != 0 { - return nil, errors.ErrNilMultiSigner + return nil, errors.ErrMissingEpochZeroMultiSignerConfig } for i, mConfig := range sortedMultiSignerConfig { diff --git a/factory/crypto/multiSignerContainer_test.go b/factory/crypto/multiSignerContainer_test.go index 66dbfba1244..332c96ae0fd 100644 --- a/factory/crypto/multiSignerContainer_test.go +++ b/factory/crypto/multiSignerContainer_test.go @@ -34,7 +34,7 @@ func Test_NewMultiSignerContainer(t *testing.T) { multiSigContainer, err := NewMultiSignerContainer(args, multiSigConfigClone) require.Nil(t, multiSigContainer) - require.Equal(t, errors.ErrNilMultiSigner, err) + require.Equal(t, errors.ErrMissingEpochZeroMultiSignerConfig, err) }) t.Run("invalid multiSigner type should err", func(t *testing.T) { multiSigConfigClone := append([]config.MultiSignerConfig{}, multiSigConfig...) From 9f378a59e5737785360ca41444e1eb58a665124c Mon Sep 17 00:00:00 2001 From: ssd04 Date: Fri, 29 Jul 2022 14:57:22 +0300 Subject: [PATCH 10/10] factory crypto: error and comments updates --- errors/errors.go | 3 +++ factory/crypto/multiSignerContainer.go | 4 ++-- factory/crypto/multiSignerContainer_test.go | 2 +- 3 files changed, 6 insertions(+), 3 deletions(-) diff --git a/errors/errors.go b/errors/errors.go index 582b28c7378..be6d5c12853 100644 --- a/errors/errors.go +++ b/errors/errors.go @@ -485,6 +485,9 @@ var ErrSignerNotSupported = errors.New("signer not supported") // ErrMissingMultiSignerConfig signals that the multisigner config is missing var ErrMissingMultiSignerConfig = errors.New("multisigner configuration missing") +// ErrMissingMultiSigner signals that there is no multisigner instance available +var ErrMissingMultiSigner = errors.New("multisigner instance missing") + // ErrMissingEpochZeroMultiSignerConfig signals that the multisigner config for epoch zero is missing var ErrMissingEpochZeroMultiSignerConfig = errors.New("multisigner configuration missing for epoch zero") diff --git a/factory/crypto/multiSignerContainer.go b/factory/crypto/multiSignerContainer.go index 321658f8326..b886bfa0ad4 100644 --- a/factory/crypto/multiSignerContainer.go +++ b/factory/crypto/multiSignerContainer.go @@ -70,7 +70,7 @@ func NewMultiSignerContainer(args MultiSigArgs, multiSignerConfig []config.Multi return c, nil } -// GetMultiSigner returns the multiSignerContainer configured for the given epoch +// GetMultiSigner returns the multiSigner configured for the given epoch func (c *container) GetMultiSigner(epoch uint32) (crypto.MultiSigner, error) { c.mutSigners.RLock() defer c.mutSigners.RUnlock() @@ -80,7 +80,7 @@ func (c *container) GetMultiSigner(epoch uint32) (crypto.MultiSigner, error) { return c.multiSigners[i].multiSigner, nil } } - return nil, errors.ErrMissingMultiSignerConfig + return nil, errors.ErrMissingMultiSigner } // IsInterfaceNil returns true if the underlying object is nil diff --git a/factory/crypto/multiSignerContainer_test.go b/factory/crypto/multiSignerContainer_test.go index 332c96ae0fd..1d3b52d0941 100644 --- a/factory/crypto/multiSignerContainer_test.go +++ b/factory/crypto/multiSignerContainer_test.go @@ -64,7 +64,7 @@ func TestContainer_GetMultiSigner(t *testing.T) { multiSigner, err := multiSigContainer.GetMultiSigner(0) require.Nil(t, multiSigner) - require.Equal(t, errors.ErrMissingMultiSignerConfig, err) + require.Equal(t, errors.ErrMissingMultiSigner, err) }) t.Run("get multi signer OK", func(t *testing.T) { multiSigContainer, _ := NewMultiSignerContainer(args, multiSigConfig)