From 743b92a80906fa950ff8e0cd0883b2d629cac519 Mon Sep 17 00:00:00 2001 From: jules01 Date: Wed, 28 Sep 2022 10:40:24 +0300 Subject: [PATCH] - fixes after merge --- consensus/interface.go | 1 + consensus/mock/signatureHandlerStub.go | 26 ++++--- consensus/signing/signing.go | 13 +++- consensus/spos/bls/subroundSignature.go | 33 +++++---- consensus/spos/subround_test.go | 1 + factory/crypto/cryptoComponents.go | 18 ++--- factory/crypto/cryptoComponentsHandler.go | 6 +- .../heartbeat/heartbeatV2Components_test.go | 2 + factory/mock/cryptoComponentsMock.go | 6 +- integrationTests/mock/cryptoComponentsStub.go | 6 +- integrationTests/testConsensusNode.go | 18 +++-- integrationTests/testProcessorNode.go | 3 +- node/mock/factory/cryptoComponentsStub.go | 6 +- p2p/crypto/errors.go | 5 -- p2p/crypto/identityGenerator.go | 60 ---------------- p2p/crypto/identityGenerator_test.go | 69 ------------------- p2p/interface.go | 6 ++ p2p/p2p.go | 6 ++ 18 files changed, 105 insertions(+), 180 deletions(-) delete mode 100644 p2p/crypto/errors.go delete mode 100644 p2p/crypto/identityGenerator.go delete mode 100644 p2p/crypto/identityGenerator_test.go diff --git a/consensus/interface.go b/consensus/interface.go index a6734cad18c..0ef9c0cda88 100644 --- a/consensus/interface.go +++ b/consensus/interface.go @@ -153,6 +153,7 @@ type ScheduledProcessor interface { type SignatureHandler interface { Reset(pubKeys []string) error CreateSignatureShare(msg []byte, index uint16, epoch uint32) ([]byte, error) + CreateSignatureShareWithPrivateKey(message []byte, index uint16, epoch uint32, privateKeyBytes []byte) ([]byte, error) StoreSignatureShare(index uint16, sig []byte) error SignatureShare(index uint16) ([]byte, error) VerifySignatureShare(index uint16, sig []byte, msg []byte, epoch uint32) error diff --git a/consensus/mock/signatureHandlerStub.go b/consensus/mock/signatureHandlerStub.go index 802b4ae908f..c1d25eb0195 100644 --- a/consensus/mock/signatureHandlerStub.go +++ b/consensus/mock/signatureHandlerStub.go @@ -2,14 +2,15 @@ package mock // SignatureHandlerStub implements SignatureHandler interface type SignatureHandlerStub struct { - ResetCalled func(pubKeys []string) error - CreateSignatureShareCalled func(msg []byte, index uint16, epoch uint32) ([]byte, error) - StoreSignatureShareCalled func(index uint16, sig []byte) error - SignatureShareCalled func(index uint16) ([]byte, error) - VerifySignatureShareCalled func(index uint16, sig []byte, msg []byte, epoch uint32) error - AggregateSigsCalled func(bitmap []byte, epoch uint32) ([]byte, error) - SetAggregatedSigCalled func(_ []byte) error - VerifyCalled func(msg []byte, bitmap []byte, epoch uint32) error + ResetCalled func(pubKeys []string) error + CreateSignatureShareCalled func(msg []byte, index uint16, epoch uint32) ([]byte, error) + CreateSignatureShareWithPrivateKeyCalled func(message []byte, index uint16, epoch uint32, privateKeyBytes []byte) ([]byte, error) + StoreSignatureShareCalled func(index uint16, sig []byte) error + SignatureShareCalled func(index uint16) ([]byte, error) + VerifySignatureShareCalled func(index uint16, sig []byte, msg []byte, epoch uint32) error + AggregateSigsCalled func(bitmap []byte, epoch uint32) ([]byte, error) + SetAggregatedSigCalled func(_ []byte) error + VerifyCalled func(msg []byte, bitmap []byte, epoch uint32) error } // Reset - @@ -30,6 +31,15 @@ func (stub *SignatureHandlerStub) CreateSignatureShare(msg []byte, index uint16, return []byte("sigShare"), nil } +// CreateSignatureShareWithPrivateKey - +func (stub *SignatureHandlerStub) CreateSignatureShareWithPrivateKey(message []byte, index uint16, epoch uint32, privateKeyBytes []byte) ([]byte, error) { + if stub.CreateSignatureShareWithPrivateKeyCalled != nil { + return stub.CreateSignatureShareWithPrivateKeyCalled(message, index, epoch, privateKeyBytes) + } + + return make([]byte, 0), nil +} + // StoreSignatureShare - func (stub *SignatureHandlerStub) StoreSignatureShare(index uint16, sig []byte) error { if stub.StoreSignatureShareCalled != nil { diff --git a/consensus/signing/signing.go b/consensus/signing/signing.go index 90761a34fb8..3a84c841754 100644 --- a/consensus/signing/signing.go +++ b/consensus/signing/signing.go @@ -122,6 +122,15 @@ func (sh *signatureHolder) Reset(pubKeys []string) error { // CreateSignatureShare returns a signature over a message func (sh *signatureHolder) CreateSignatureShare(message []byte, selfIndex uint16, epoch uint32) ([]byte, error) { + sh.mutSigningData.RLock() + privateKeyBytes := sh.data.privKey + sh.mutSigningData.RUnlock() + + return sh.CreateSignatureShareWithPrivateKey(message, selfIndex, epoch, privateKeyBytes) +} + +// CreateSignatureShareWithPrivateKey returns a signature over a message providing the private key bytes +func (sh *signatureHolder) CreateSignatureShareWithPrivateKey(message []byte, index uint16, epoch uint32, privateKeyBytes []byte) ([]byte, error) { if message == nil { return nil, ErrNilMessage } @@ -134,12 +143,12 @@ func (sh *signatureHolder) CreateSignatureShare(message []byte, selfIndex uint16 return nil, err } - sigShareBytes, err := multiSigner.CreateSignatureShare(sh.data.privKey, message) + sigShareBytes, err := multiSigner.CreateSignatureShare(privateKeyBytes, message) if err != nil { return nil, err } - sh.data.sigShares[selfIndex] = sigShareBytes + sh.data.sigShares[index] = sigShareBytes return sigShareBytes, nil } diff --git a/consensus/spos/bls/subroundSignature.go b/consensus/spos/bls/subroundSignature.go index 5fec2cd531f..9598448c8f0 100644 --- a/consensus/spos/bls/subroundSignature.go +++ b/consensus/spos/bls/subroundSignature.go @@ -73,21 +73,16 @@ func (sr *subroundSignature) doSignatureJob(_ context.Context) bool { return false } - selfIndex, err := sr.SelfConsensusGroupIndex() - if err != nil { - log.Debug("doSignatureJob.SelfConsensusGroupIndex: not in consensus group") - return false - } - - signatureShare, err := sr.SignatureHandler().CreateSignatureShare(sr.GetData(), uint16(selfIndex), sr.Header.GetEpoch()) - if err != nil { - log.Debug("doSignatureJob.CreateSignatureShare", "error", err.Error()) - return false - } isSelfLeader := sr.IsSelfLeaderInCurrentRound() if isSelfLeader || sr.IsNodeInConsensusGroup(sr.SelfPubKey()) { - signatureShare, err := sr.MultiSigner().CreateSignatureShare(sr.GetData(), nil) + selfIndex, err := sr.SelfConsensusGroupIndex() + if err != nil { + log.Debug("doSignatureJob.SelfConsensusGroupIndex: not in consensus group") + return false + } + + signatureShare, err := sr.SignatureHandler().CreateSignatureShare(sr.GetData(), uint16(selfIndex), sr.Header.GetEpoch()) if err != nil { log.Debug("doSignatureJob.CreateSignatureShare", "error", err.Error()) return false @@ -368,7 +363,19 @@ func (sr *subroundSignature) doSignatureJobForManagedKeys() bool { } managedPrivateKey := sr.GetMessageSigningPrivateKey(pkBytes) - signatureShare, err := sr.MultiSigner().CreateAndAddSignatureShareForKey(sr.GetData(), managedPrivateKey, pkBytes) + selfIndex, err := sr.ConsensusGroupIndex(pk) + if err != nil { + log.Warn("doSignatureJobForManagedKeys: index not found", "pk", pkBytes) + continue + } + + managedPrivateKeyBytes, err := managedPrivateKey.ToByteArray() + if err != nil { + log.Warn("doSignatureJobForManagedKeys: can not recover the private key bytes", "pk", pkBytes) + continue + } + + signatureShare, err := sr.SignatureHandler().CreateSignatureShareWithPrivateKey(sr.GetData(), uint16(selfIndex), sr.Header.GetEpoch(), managedPrivateKeyBytes) if err != nil { log.Debug("doSignatureJobForManagedKeys.CreateAndAddSignatureShareForKey", "error", err.Error()) return false diff --git a/consensus/spos/subround_test.go b/consensus/spos/subround_test.go index a5c9a723ab9..542c15fd58b 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" "github.com/ElrondNetwork/elrond-go/testscommon/cryptoMocks" "github.com/ElrondNetwork/elrond-go/testscommon/statusHandler" "github.com/stretchr/testify/assert" diff --git a/factory/crypto/cryptoComponents.go b/factory/crypto/cryptoComponents.go index c10390f8b3f..7d5d2c7a893 100644 --- a/factory/crypto/cryptoComponents.go +++ b/factory/crypto/cryptoComponents.go @@ -24,7 +24,7 @@ import ( "github.com/ElrondNetwork/elrond-go/genesis/process/disabled" "github.com/ElrondNetwork/elrond-go/heartbeat" "github.com/ElrondNetwork/elrond-go/keysManagement" - p2pCrypto "github.com/ElrondNetwork/elrond-go/p2p/crypto" + "github.com/ElrondNetwork/elrond-go/p2p" storageFactory "github.com/ElrondNetwork/elrond-go/storage/factory" "github.com/ElrondNetwork/elrond-go/storage/storageunit" "github.com/ElrondNetwork/elrond-go/vm" @@ -43,8 +43,8 @@ type CryptoComponentsFactoryArgs struct { Config config.Config EnableEpochs config.EnableEpochs PrefsConfig config.Preferences - CoreComponentsHolder CoreComponentsHolder - KeyLoader KeyLoaderHandler + CoreComponentsHolder factory.CoreComponentsHolder + KeyLoader factory.KeyLoaderHandler ActivateBLSPubKeyMessageVerification bool IsInImportMode bool ImportModeNoSigCheck bool @@ -58,7 +58,7 @@ type cryptoComponentsFactory struct { config config.Config enableEpochs config.EnableEpochs prefsConfig config.Preferences - coreComponentsHolder CoreComponentsHolder + coreComponentsHolder factory.CoreComponentsHolder activateBLSPubKeyMessageVerification bool keyLoader factory.KeyLoaderHandler isInImportMode bool @@ -84,8 +84,8 @@ type cryptoComponents struct { blockSignKeyGen crypto.KeyGenerator txSignKeyGen crypto.KeyGenerator messageSignVerifier vm.MessageSignVerifier - managedPeersHolder heartbeat.ManagedPeersHolder - keysHandler consensus.KeysHandler + managedPeersHolder heartbeat.ManagedPeersHolder + keysHandler consensus.KeysHandler cryptoParams } @@ -180,7 +180,7 @@ func (ccf *cryptoComponentsFactory) Create() (*cryptoComponents, error) { isMainMachine := redundancyLevel == mainMachineRedundancyLevel argsManagedPeersHolder := keysManagement.ArgsManagedPeersHolder{ KeyGenerator: blockSignKeyGen, - P2PIdentityGenerator: p2pCrypto.NewIdentityGenerator(), + P2PIdentityGenerator: p2p.NewRandomP2PIdentityGenerator(), IsMainMachine: isMainMachine, MaxRoundsWithoutReceivedMessages: redundancyLevel, PrefsConfig: ccf.prefsConfig, @@ -200,8 +200,8 @@ func (ccf *cryptoComponentsFactory) Create() (*cryptoComponents, error) { blockSignKeyGen: blockSignKeyGen, txSignKeyGen: txSignKeyGen, messageSignVerifier: messageSignVerifier, - managedPeersHolder: managedPeersHolder, - keysHandler: keysManagement.NewKeysHandler(), + managedPeersHolder: managedPeersHolder, + keysHandler: keysManagement.NewKeysHandler(), cryptoParams: *cp, }, nil } diff --git a/factory/crypto/cryptoComponentsHandler.go b/factory/crypto/cryptoComponentsHandler.go index 03aede9a559..de44d33ee5a 100644 --- a/factory/crypto/cryptoComponentsHandler.go +++ b/factory/crypto/cryptoComponentsHandler.go @@ -7,8 +7,10 @@ import ( "github.com/ElrondNetwork/elrond-go-core/core/check" 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/errors" "github.com/ElrondNetwork/elrond-go/factory" + "github.com/ElrondNetwork/elrond-go/heartbeat" "github.com/ElrondNetwork/elrond-go/vm" ) @@ -317,8 +319,8 @@ func (mcc *managedCryptoComponents) Clone() interface{} { blockSignKeyGen: mcc.BlockSignKeyGen(), txSignKeyGen: mcc.TxSignKeyGen(), messageSignVerifier: mcc.MessageSignVerifier(), - managedPeersHolder: mcc.ManagedPeersHolder(), - keysHandler: mcc.KeysHandler(), + managedPeersHolder: mcc.ManagedPeersHolder(), + keysHandler: mcc.KeysHandler(), cryptoParams: mcc.cryptoParams, } } diff --git a/factory/heartbeat/heartbeatV2Components_test.go b/factory/heartbeat/heartbeatV2Components_test.go index 8d2829c1f3c..cccfd279954 100644 --- a/factory/heartbeat/heartbeatV2Components_test.go +++ b/factory/heartbeat/heartbeatV2Components_test.go @@ -48,6 +48,7 @@ func createMockHeartbeatV2ComponentsFactoryArgs() heartbeatComp.ArgHeartbeatV2Co HideInactiveValidatorIntervalInSec: 60, HardforkTimeBetweenSendsInSec: 5, TimeBetweenConnectionsMetricsUpdateInSec: 10, + PeerAuthenticationTimeBetweenChecksInSec: 6, HeartbeatPool: config.CacheConfig{ Type: "LRU", Capacity: 1000, @@ -64,6 +65,7 @@ func createMockHeartbeatV2ComponentsFactoryArgs() heartbeatComp.ArgHeartbeatV2Co Identity: "identity", }, }, + BaseVersion: "test-base", AppVersion: "test", BoostrapComponents: bootstrapC, CoreComponents: coreC, diff --git a/factory/mock/cryptoComponentsMock.go b/factory/mock/cryptoComponentsMock.go index fcd6c9a81bd..8941f1bac30 100644 --- a/factory/mock/cryptoComponentsMock.go +++ b/factory/mock/cryptoComponentsMock.go @@ -6,6 +6,8 @@ import ( "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/heartbeat" "github.com/ElrondNetwork/elrond-go/vm" ) @@ -18,7 +20,7 @@ type CryptoComponentsMock struct { PubKeyBytes []byte BlockSig crypto.SingleSigner TxSig crypto.SingleSigner - MultiSigContainer cryptoCommon.MultiSignerContainer + MultiSigContainer cryptoCommon.MultiSignerContainer PeerSignHandler crypto.PeerSignatureHandler BlKeyGen crypto.KeyGenerator TxKeyGen crypto.KeyGenerator @@ -135,7 +137,7 @@ func (ccm *CryptoComponentsMock) Clone() interface{} { PubKeyBytes: ccm.PubKeyBytes, BlockSig: ccm.BlockSig, TxSig: ccm.TxSig, - MultiSigContainer: ccm.MultiSigContainer, + MultiSigContainer: ccm.MultiSigContainer, PeerSignHandler: ccm.PeerSignHandler, BlKeyGen: ccm.BlKeyGen, TxKeyGen: ccm.TxKeyGen, diff --git a/integrationTests/mock/cryptoComponentsStub.go b/integrationTests/mock/cryptoComponentsStub.go index 5dca6a5b81d..b30fce753fc 100644 --- a/integrationTests/mock/cryptoComponentsStub.go +++ b/integrationTests/mock/cryptoComponentsStub.go @@ -6,6 +6,8 @@ import ( "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/heartbeat" "github.com/ElrondNetwork/elrond-go/vm" ) @@ -18,7 +20,7 @@ type CryptoComponentsStub struct { PubKeyBytes []byte BlockSig crypto.SingleSigner TxSig crypto.SingleSigner - MultiSigContainer cryptoCommon.MultiSignerContainer + MultiSigContainer cryptoCommon.MultiSignerContainer PeerSignHandler crypto.PeerSignatureHandler BlKeyGen crypto.KeyGenerator TxKeyGen crypto.KeyGenerator @@ -150,7 +152,7 @@ func (ccs *CryptoComponentsStub) Clone() interface{} { PubKeyBytes: ccs.PubKeyBytes, BlockSig: ccs.BlockSig, TxSig: ccs.TxSig, - MultiSigContainer: ccs.MultiSigContainer, + MultiSigContainer: ccs.MultiSigContainer, PeerSignHandler: ccs.PeerSignHandler, BlKeyGen: ccs.BlKeyGen, TxKeyGen: ccs.TxKeyGen, diff --git a/integrationTests/testConsensusNode.go b/integrationTests/testConsensusNode.go index 0c6570100c2..00f9e60e21c 100644 --- a/integrationTests/testConsensusNode.go +++ b/integrationTests/testConsensusNode.go @@ -206,6 +206,11 @@ func (tcn *TestConsensusNode) initNode( }, } + networkComponents := GetDefaultNetworkComponents() + networkComponents.Messenger = tcn.Messenger + networkComponents.InputAntiFlood = &mock.NilAntifloodHandler{} + networkComponents.PeerHonesty = &mock.PeerHonestyHandlerStub{} + cryptoComponents := GetDefaultCryptoComponents() cryptoComponents.PrivKey = tcn.NodeKeys.Sk cryptoComponents.PubKey = tcn.NodeKeys.Sk.GeneratePublic() @@ -214,6 +219,14 @@ func (tcn *TestConsensusNode) initNode( cryptoComponents.MultiSigContainer = cryptoMocks.NewMultiSignerContainerMock(testMultiSig) cryptoComponents.BlKeyGen = keyGen cryptoComponents.PeerSignHandler = peerSigHandler + cryptoComponents.KeysHandlerField = &testscommon.KeysHandlerStub{ + GetHandledPrivateKeyCalled: func(pkBytes []byte) crypto.PrivateKey { + return tcn.NodeKeys.Sk + }, + GetAssociatedPidCalled: func(pkBytes []byte) core.PeerID { + return tcn.Messenger.ID() + }, + } processComponents := GetDefaultProcessComponents() processComponents.ForkDetect = forkDetector @@ -242,11 +255,6 @@ func (tcn *TestConsensusNode) initNode( stateComponents.Accounts = tcn.AccountsDB stateComponents.AccountsAPI = tcn.AccountsDB - networkComponents := GetDefaultNetworkComponents() - networkComponents.Messenger = tcn.Messenger - networkComponents.InputAntiFlood = &mock.NilAntifloodHandler{} - networkComponents.PeerHonesty = &mock.PeerHonestyHandlerStub{} - var err error tcn.Node, err = node.NewNode( node.WithCoreComponents(coreComponents), diff --git a/integrationTests/testProcessorNode.go b/integrationTests/testProcessorNode.go index 26f8baa52bb..be9097ed439 100644 --- a/integrationTests/testProcessorNode.go +++ b/integrationTests/testProcessorNode.go @@ -3080,12 +3080,13 @@ func GetDefaultCryptoComponents() *mock.CryptoComponentsStub { PubKeyBytes: []byte("pubKey"), BlockSig: &mock.SignerMock{}, TxSig: &mock.SignerMock{}, - MultiSigContainer: cryptoMocks.NewMultiSignerContainerMock( TestMultiSig), + MultiSigContainer: cryptoMocks.NewMultiSignerContainerMock(TestMultiSig), PeerSignHandler: &mock.PeerSignatureHandler{}, BlKeyGen: &mock.KeyGenMock{}, TxKeyGen: &mock.KeyGenMock{}, MsgSigVerifier: &testscommon.MessageSignVerifierMock{}, ManagedPeersHolderField: &testscommon.ManagedPeersHolderStub{}, + KeysHandlerField: &testscommon.KeysHandlerStub{}, } } diff --git a/node/mock/factory/cryptoComponentsStub.go b/node/mock/factory/cryptoComponentsStub.go index e19aea18b27..368a93d67b1 100644 --- a/node/mock/factory/cryptoComponentsStub.go +++ b/node/mock/factory/cryptoComponentsStub.go @@ -6,6 +6,8 @@ import ( "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/heartbeat" "github.com/ElrondNetwork/elrond-go/vm" ) @@ -18,7 +20,7 @@ type CryptoComponentsMock struct { PubKeyBytes []byte BlockSig crypto.SingleSigner TxSig crypto.SingleSigner - MultiSigContainer cryptoCommon.MultiSignerContainer + MultiSigContainer cryptoCommon.MultiSignerContainer PeerSignHandler crypto.PeerSignatureHandler BlKeyGen crypto.KeyGenerator TxKeyGen crypto.KeyGenerator @@ -150,7 +152,7 @@ func (ccm *CryptoComponentsMock) Clone() interface{} { PubKeyBytes: ccm.PubKeyBytes, BlockSig: ccm.BlockSig, TxSig: ccm.TxSig, - MultiSigContainer: ccm.MultiSigContainer, + MultiSigContainer: ccm.MultiSigContainer, PeerSignHandler: ccm.PeerSignHandler, BlKeyGen: ccm.BlKeyGen, TxKeyGen: ccm.TxKeyGen, diff --git a/p2p/crypto/errors.go b/p2p/crypto/errors.go deleted file mode 100644 index f6ca563a14a..00000000000 --- a/p2p/crypto/errors.go +++ /dev/null @@ -1,5 +0,0 @@ -package crypto - -import "errors" - -var errNilPrivateKey = errors.New("nil private key") diff --git a/p2p/crypto/identityGenerator.go b/p2p/crypto/identityGenerator.go deleted file mode 100644 index 4389636f7a6..00000000000 --- a/p2p/crypto/identityGenerator.go +++ /dev/null @@ -1,60 +0,0 @@ -package crypto - -import ( - "crypto/ecdsa" - - "github.com/ElrondNetwork/elrond-go-core/core" - randFactory "github.com/ElrondNetwork/elrond-go/p2p/libp2p/rand/factory" - "github.com/btcsuite/btcd/btcec" - "github.com/libp2p/go-libp2p-core/crypto" - "github.com/libp2p/go-libp2p-core/peer" -) - -const emptySeed = "" - -type identityGenerator struct { -} - -// NewIdentityGenerator creates a new identity generator -func NewIdentityGenerator() *identityGenerator { - return &identityGenerator{} -} - -// CreateRandomP2PIdentity creates a valid random p2p identity to sign messages on the behalf of other identity -func (generator *identityGenerator) CreateRandomP2PIdentity() ([]byte, core.PeerID, error) { - sk, err := generator.CreateP2PPrivateKey(emptySeed) - if err != nil { - return nil, "", err - } - - skBuff, err := crypto.MarshalPrivateKey(sk) - if err != nil { - return nil, "", err - } - - pid, err := peer.IDFromPublicKey(sk.GetPublic()) - if err != nil { - return nil, "", err - } - - return skBuff, core.PeerID(pid), nil -} - -// CreateP2PPrivateKey will create a new P2P private key based on the provided seed. If the seed is the empty string -// it will use the crypto's random generator to provide a random one. Otherwise, it will create a deterministic private -// key. This is useful when we want a private key that never changes, such as in the network seeders -func (generator *identityGenerator) CreateP2PPrivateKey(seed string) (*crypto.Secp256k1PrivateKey, error) { - randReader, err := randFactory.NewRandFactory(seed) - if err != nil { - return nil, err - } - - prvKey, _ := ecdsa.GenerateKey(btcec.S256(), randReader) - - return (*crypto.Secp256k1PrivateKey)(prvKey), nil -} - -// IsInterfaceNil returns true if there is no value under the interface -func (generator *identityGenerator) IsInterfaceNil() bool { - return generator == nil -} diff --git a/p2p/crypto/identityGenerator_test.go b/p2p/crypto/identityGenerator_test.go deleted file mode 100644 index 88ff9023656..00000000000 --- a/p2p/crypto/identityGenerator_test.go +++ /dev/null @@ -1,69 +0,0 @@ -package crypto - -import ( - "testing" - - "github.com/ElrondNetwork/elrond-go-core/core/check" - "github.com/stretchr/testify/assert" -) - -func TestNewIdentityGenerator(t *testing.T) { - t.Parallel() - - generator := NewIdentityGenerator() - assert.False(t, check.IfNil(generator)) -} - -func TestIdentityGenerator_CreateP2PPrivateKey(t *testing.T) { - t.Parallel() - - generator := NewIdentityGenerator() - seed1 := "secret seed 1" - seed2 := "secret seed 2" - t.Run("same seed should produce the same private key", func(t *testing.T) { - - sk1, err := generator.CreateP2PPrivateKey(seed1) - assert.Nil(t, err) - - sk2, err := generator.CreateP2PPrivateKey(seed1) - assert.Nil(t, err) - - assert.Equal(t, sk1, sk2) - }) - t.Run("different seed should produce different private key", func(t *testing.T) { - sk1, err := generator.CreateP2PPrivateKey(seed1) - assert.Nil(t, err) - - sk2, err := generator.CreateP2PPrivateKey(seed2) - assert.Nil(t, err) - - assert.NotEqual(t, sk1, sk2) - }) - t.Run("empty seed should produce different private key", func(t *testing.T) { - sk1, err := generator.CreateP2PPrivateKey("") - assert.Nil(t, err) - - sk2, err := generator.CreateP2PPrivateKey("") - assert.Nil(t, err) - - assert.NotEqual(t, sk1, sk2) - }) -} - -func TestIdentityGenerator_CreateRandomP2PIdentity(t *testing.T) { - t.Parallel() - - generator := NewIdentityGenerator() - sk1, pid1, err := generator.CreateRandomP2PIdentity() - assert.Nil(t, err) - - sk2, pid2, err := generator.CreateRandomP2PIdentity() - assert.Nil(t, err) - - assert.NotEqual(t, sk1, sk2) - assert.NotEqual(t, pid1, pid2) - assert.Equal(t, 36, len(sk1)) - assert.Equal(t, 39, len(pid1)) - assert.Equal(t, 36, len(sk2)) - assert.Equal(t, 39, len(pid2)) -} diff --git a/p2p/interface.go b/p2p/interface.go index 74bbaf7a0f4..a49b2bc787c 100644 --- a/p2p/interface.go +++ b/p2p/interface.go @@ -95,3 +95,9 @@ type PeersRatingHandler interface { GetTopRatedPeersFromList(peers []core.PeerID, minNumOfPeersExpected int) []core.PeerID IsInterfaceNil() bool } + +// RandomP2PIdentityGenerator defines an entity that is able to generate a random p2p identity +type RandomP2PIdentityGenerator interface { + CreateRandomP2PIdentity() ([]byte, core.PeerID, error) + IsInterfaceNil() bool +} diff --git a/p2p/p2p.go b/p2p/p2p.go index 711152ef680..f555be50eb1 100644 --- a/p2p/p2p.go +++ b/p2p/p2p.go @@ -3,6 +3,7 @@ package p2p import ( p2p "github.com/ElrondNetwork/elrond-go-p2p" "github.com/ElrondNetwork/elrond-go-p2p/libp2p" + "github.com/ElrondNetwork/elrond-go-p2p/libp2p/crypto" "github.com/ElrondNetwork/elrond-go-p2p/message" "github.com/ElrondNetwork/elrond-go-p2p/peersHolder" "github.com/ElrondNetwork/elrond-go-p2p/rating" @@ -37,3 +38,8 @@ func NewPeersRatingHandler(args ArgPeersRatingHandler) (p2p.PeersRatingHandler, func NewPeersHolder(preferredConnectionAddresses []string) (p2p.PreferredPeersHolderHandler, error) { return peersHolder.NewPeersHolder(preferredConnectionAddresses) } + +// NewRandomP2PIdentityGenerator creates a new identity generator +func NewRandomP2PIdentityGenerator() RandomP2PIdentityGenerator { + return crypto.NewIdentityGenerator() +}