Fixed managedPeersHolder for badly configured node

keysManagement/managedPeersHolder.go

@@ -22,6 +22,7 @@ var log = logger.GetOrCreate("keysManagement")
 type managedPeersHolder struct {
 	mut                              sync.RWMutex
 	defaultPeerInfoCurrentIndex      int
+	providedIdentities               map[string]*peerInfo
 	data                             map[string]*peerInfo
 	pids                             map[core.PeerID]struct{}
 	keyGenerator                     crypto.KeyGenerator
@@ -60,9 +61,10 @@ func NewManagedPeersHolder(args ArgsManagedPeersHolder) (*managedPeersHolder, er
 		defaultName:                      args.PrefsConfig.Preferences.NodeDisplayName,
 		defaultIdentity:                  args.PrefsConfig.Preferences.Identity,
 		p2pKeyConverter:                  args.P2PKeyConverter,
+		data:                             make(map[string]*peerInfo),
 	}
 
-	holder.data, err = holder.createDataMap(args.PrefsConfig.NamedIdentity)
+	holder.providedIdentities, err = holder.createProvidedIdentitiesMap(args.PrefsConfig.NamedIdentity)
 	if err != nil {
 		return nil, err
 	}
@@ -88,7 +90,7 @@ func checkManagedPeersHolderArgs(args ArgsManagedPeersHolder) error {
 	return nil
 }
 
-func (holder *managedPeersHolder) createDataMap(namedIdentities []config.NamedIdentity) (map[string]*peerInfo, error) {
+func (holder *managedPeersHolder) createProvidedIdentitiesMap(namedIdentities []config.NamedIdentity) (map[string]*peerInfo, error) {
 	dataMap := make(map[string]*peerInfo)
 
 	for _, identity := range namedIdentities {
@@ -159,6 +161,7 @@ func (holder *managedPeersHolder) AddManagedPeer(privateKeyBytes []byte) error {
 			ErrDuplicatedKey, hex.EncodeToString(privateKeyBytes), hex.EncodeToString(publicKeyBytes))
 	}
 
+	pInfo, found = holder.providedIdentities[string(publicKeyBytes)]
 	if !found {
 		pInfo = &peerInfo{
 			machineID:    generateRandomMachineID(),

keysManagement/managedPeersHolder_test.go

@@ -347,18 +347,68 @@ func TestManagedPeersHolder_GetPrivateKey(t *testing.T) {
 
 	holder, _ := keysManagement.NewManagedPeersHolder(args)
 	_ = holder.AddManagedPeer(skBytes0)
+
+	testName := "test name"
+	testIdentity := "test identity"
+
 	t.Run("public key not added should error", func(t *testing.T) {
 		skRecovered, err := holder.GetPrivateKey(pkBytes1)
 		assert.Nil(t, skRecovered)
 		assert.True(t, errors.Is(err, keysManagement.ErrMissingPublicKeyDefinition))
 	})
+	t.Run("identity provided but not the actual key should not provide a nil key", func(t *testing.T) {
+		argsLocal := createMockArgsManagedPeersHolder()
+		blsKey := "aabb1122"
+		namedIdentity := config.NamedIdentity{
+			Identity: testIdentity,
+			NodeName: testName,
+			BLSKeys:  []string{blsKey},
+		}
+
+		argsLocal.PrefsConfig.NamedIdentity = append(argsLocal.PrefsConfig.NamedIdentity, namedIdentity)
+		holderLocal, err := keysManagement.NewManagedPeersHolder(argsLocal)
+		assert.Nil(t, err)
+
+		keyUnhexed, _ := hex.DecodeString(blsKey)
+		skRecovered, err := holderLocal.GetPrivateKey(keyUnhexed)
+		assert.Nil(t, skRecovered)
+		assert.ErrorIs(t, err, keysManagement.ErrMissingPublicKeyDefinition)
+
+		name, identity, err := holderLocal.GetNameAndIdentity(keyUnhexed)
+		assert.ErrorIs(t, err, keysManagement.ErrMissingPublicKeyDefinition)
+		assert.Empty(t, name)
+		assert.Empty(t, identity)
+	})
 	t.Run("public key exists should return the private key", func(t *testing.T) {
 		skRecovered, err := holder.GetPrivateKey(pkBytes0)
 		assert.Nil(t, err)
 
 		skBytesRecovered, _ := skRecovered.ToByteArray()
 		assert.Equal(t, skBytes0, skBytesRecovered)
 	})
+	t.Run("identity provided and the actual key should work", func(t *testing.T) {
+		argsLocal := createMockArgsManagedPeersHolder()
+		namedIdentity := config.NamedIdentity{
+			Identity: testIdentity,
+			NodeName: testName,
+			BLSKeys:  []string{hex.EncodeToString(pkBytes0)},
+		}
+
+		argsLocal.PrefsConfig.NamedIdentity = append(argsLocal.PrefsConfig.NamedIdentity, namedIdentity)
+		holderLocal, err := keysManagement.NewManagedPeersHolder(argsLocal)
+		assert.Nil(t, err)
+
+		_ = holderLocal.AddManagedPeer(skBytes0)
+		skRecovered, err := holderLocal.GetPrivateKey(pkBytes0)
+		skBytesRecovered, _ := skRecovered.ToByteArray()
+		assert.Equal(t, skBytes0, skBytesRecovered)
+		assert.Nil(t, err)
+
+		name, identity, err := holderLocal.GetNameAndIdentity(pkBytes0)
+		assert.Nil(t, err)
+		assert.Equal(t, testName+"-00", name)
+		assert.Equal(t, testIdentity, identity)
+	})
 }
 
 func TestManagedPeersHolder_GetP2PIdentity(t *testing.T) {