mark invalid encrypted shares as 'invalid'

eth/eventhandler/event_handler_test.go

@@ -417,6 +417,7 @@ func TestHandleBlockEventsStream(t *testing.T) {
 			// Corrupt the encrypted last share key of the 4th operator
 			malformedSharesData[len(malformedSharesData)-1] ^= 1
 
+			valPubKey := validatorData2.masterPubKey.Serialize()
 			// Call the contract method
 			_, err = boundContract.SimcontractTransactor.RegisterValidator(
 				auth,
@@ -454,30 +455,39 @@ func TestHandleBlockEventsStream(t *testing.T) {
 			// Check that validator was registered for op1,
 			shares = eh.nodeStorage.Shares().List(nil)
 			require.Equal(t, 2, len(shares))
+			valShare := eh.nodeStorage.Shares().Get(nil, valPubKey)
+			require.NotNil(t, valShare)
+			require.False(t, valShare.Invalid)
 			// and nonce was bumped
 			nonce, err = eh.nodeStorage.GetNextNonce(nil, testAddr)
 			require.NoError(t, err)
 			require.Equal(t, registrystorage.Nonce(3), nonce)
 		})
 
-		// Share for 1st operator is malformed; check nonce is bumped correctly; validator wasn't added
-		// slashing protection data is not added
-		t.Run("test malformed ValidatorAdded and nonce is bumped", func(t *testing.T) {
-			malformedSharesData := sharesData3[:]
+		t.Run("test malformed ValidatorAdded, nonce is bumped, share is saved, marked as invalid", func(t *testing.T) {
+			validatorData, err := createNewValidator(ops)
+			require.NoError(t, err)
+
+			sharesData, err := generateSharesData(validatorData, ops, testAddr, 3)
+			require.NoError(t, err)
+			incorrectSharesData, err := generateSharesDataWrong(validatorData, ops, testAddr, 4)
+			require.NoError(t, err)
 
-			operatorCount := len(ops)
 			signatureOffset := phase0.SignatureLength
-			pubKeysOffset := phase0.PublicKeyLength*operatorCount + signatureOffset
 
-			// Corrupt the encrypted share key of the operator 1
-			malformedSharesData[pubKeysOffset+encryptedKeyLength-1] ^= 1
+			for i := 0; i < signatureOffset; i++ {
+				incorrectSharesData[i] = sharesData[i]
+			}
+
+			require.NoError(t, err)
 
+			valPubKey := validatorData.masterPubKey.Serialize()
 			// Call the contract method
 			_, err = boundContract.SimcontractTransactor.RegisterValidator(
 				auth,
-				validatorData3.masterPubKey.Serialize(),
+				valPubKey,
 				[]uint64{1, 2, 3, 4},
-				malformedSharesData,
+				incorrectSharesData,
 				big.NewInt(100_000_000),
 				simcontract.CallableCluster{
 					ValidatorCount:  1,
@@ -504,11 +514,15 @@ func TestHandleBlockEventsStream(t *testing.T) {
 			require.Equal(t, blockNum+1, lastProcessedBlock)
 			blockNum++
 
-			requireKeyManagerDataToNotExist(t, eh, 2, validatorData3)
+			// TODO. Fix the behavior of event_handler.go
+			requireKeyManagerDataToNotExist(t, eh, 2, validatorData)
 
 			// Check that validator was not registered
 			shares = eh.nodeStorage.Shares().List(nil)
-			require.Equal(t, 2, len(shares))
+			require.Equal(t, 3, len(shares))
+			valShare := eh.nodeStorage.Shares().Get(nil, valPubKey)
+			require.NotNil(t, valShare)
+			require.True(t, valShare.Invalid)
 			// and nonce was bumped
 			nonce, err = eh.nodeStorage.GetNextNonce(nil, testAddr)
 			require.NoError(t, err)
@@ -557,7 +571,7 @@ func TestHandleBlockEventsStream(t *testing.T) {
 
 			// Check that validator was registered
 			shares = eh.nodeStorage.Shares().List(nil)
-			require.Equal(t, 3, len(shares))
+			require.Equal(t, 4, len(shares))
 			// and nonce was bumped
 			nonce, err = eh.nodeStorage.GetNextNonce(nil, testAddr)
 			require.NoError(t, err)
@@ -607,7 +621,7 @@ func TestHandleBlockEventsStream(t *testing.T) {
 
 			// Check that validator was registered
 			shares = eh.nodeStorage.Shares().List(nil)
-			require.Equal(t, 4, len(shares))
+			require.Equal(t, 5, len(shares))
 			// and nonce was bumped
 			nonce, err = eh.nodeStorage.GetNextNonce(nil, testAddr2)
 			require.NoError(t, err)
@@ -736,7 +750,7 @@ func TestHandleBlockEventsStream(t *testing.T) {
 
 			// Check the validator was removed from the validator shares storage.
 			shares := eh.nodeStorage.Shares().List(nil)
-			require.Equal(t, 3, len(shares))
+			require.Equal(t, 4, len(shares))
 			valShare = eh.nodeStorage.Shares().Get(nil, valPubKey)
 			require.Nil(t, valShare)
 			requireKeyManagerDataToNotExist(t, eh, 3, validatorData1)
@@ -1464,7 +1478,64 @@ func generateSharesData(validatorData *testValidatorData, operators []*testOpera
 
 		pubkeys = append(pubkeys, validatorData.operatorsShares[i].pub.Serialize()...)
 		encryptedShares = append(encryptedShares, ciphertext...)
+	}
+
+	tosign := fmt.Sprintf("%s:%d", owner.String(), nonce)
+	msghash := crypto.Keccak256([]byte(tosign))
+	signed := validatorData.masterKey.Sign(string(msghash))
+	sig := signed.Serialize()
+
+	if !signed.VerifyByte(validatorData.masterPubKey, msghash) {
+		return nil, errors.New("couldn't sign correctly")
+	}
+
+	sharesData := append(pubkeys, encryptedShares...)
+	sharesDataSigned := append(sig, sharesData...)
 
+	return sharesDataSigned, nil
+}
+
+func generateSharesDataWrong(validatorData *testValidatorData, operators []*testOperator, owner ethcommon.Address, nonce int) ([]byte, error) {
+	var pubkeys []byte
+	var encryptedShares []byte
+
+	for i, op := range operators {
+		pubKey := op.pub[:]
+		privKey := op.priv[:]
+
+		if i == 0 {
+			pb, sk, _ := rsaencryption.GenerateKeys()
+			pubKey = pb
+			privKey = sk
+		}
+		rsakey, err := rsaencryption.ConvertPemToPublicKey(pubKey)
+		if err != nil {
+			return nil, fmt.Errorf("cant convert publickey: %w", err)
+		}
+
+		rawshare := validatorData.operatorsShares[i].sec.SerializeToHexStr()
+		ciphertext, err := rsa.EncryptPKCS1v15(rand.Reader, rsakey, []byte(rawshare))
+		if err != nil {
+			return nil, errors.New("cant encrypt share")
+		}
+
+		rsapriv, err := rsaencryption.ConvertPemToPrivateKey(string(privKey))
+		if err != nil {
+			return nil, err
+		}
+
+		// check that we encrypt right
+		shareSecret := &bls.SecretKey{}
+		decryptedSharePrivateKey, err := rsaencryption.DecodeKey(rsapriv, ciphertext)
+		if err != nil {
+			return nil, err
+		}
+		if err = shareSecret.SetHexString(string(decryptedSharePrivateKey)); err != nil {
+			return nil, err
+		}
+
+		pubkeys = append(pubkeys, validatorData.operatorsShares[i].pub.Serialize()...)
+		encryptedShares = append(encryptedShares, ciphertext...)
 	}
 
 	tosign := fmt.Sprintf("%s:%d", owner.String(), nonce)

eth/eventhandler/handlers.go

@@ -179,12 +179,12 @@
 	}
 
 	validatorShare := eh.nodeStorage.Shares().Get(txn, event.PublicKey)
+	var malformedEventError *MalformedEventError
 
 	if validatorShare == nil {
 		createdShare, err := eh.handleShareCreation(txn, event, sharePublicKeys, encryptedKeys)
 		if err != nil {
-			var malformedEventError *MalformedEventError
-			if errors.As(err, &malformedEventError) {
+			if errors.As(err, &malformedEventError) && malformedEventError != nil && !malformedEventError.IsInvalidEncryptedShare {
 				logger.Warn("malformed event", zap.Error(err))
 
 				return nil, err
@@ -209,7 +209,7 @@
 	}
 
 	isOperatorShare := validatorShare.BelongsToOperator(eh.operatorData.GetOperatorData().ID)
-	if isOperatorShare {
+	if isOperatorShare && !validatorShare.Invalid {
 		eh.metrics.ValidatorInactive(event.PublicKey)
 		ownShare = validatorShare
 		logger = logger.With(zap.Bool("own_validator", isOperatorShare))
@@ -220,7 +220,7 @@
 }
 
 // handleShareCreation is called when a validator was added/updated during registry sync
 func (eh *EventHandler) handleShareCreation(
 	txn basedb.Txn,
 	validatorEvent *contract.ContractValidatorAdded,
 	sharePublicKeys [][]byte,
@@ -233,11 +233,23 @@
 		sharePublicKeys,
 		encryptedKeys,
 	)
+
+	var malformedEventError *MalformedEventError = nil
 	if err != nil {
-		return nil, fmt.Errorf("could not extract validator share from event: %w", err)
+		switch {
+		default:
+			return nil, fmt.Errorf("could not extract validator share from event: %w", err)
+
+		case errors.As(err, &malformedEventError):
+			if malformedEventError.IsInvalidEncryptedShare &&
+				share.BelongsToOperator(eh.operatorData.GetOperatorData().ID) {
+
+				share.Metadata.Invalid = true
+			}
+		}
 	}
 
-	if share.BelongsToOperator(eh.operatorData.GetOperatorData().ID) {
+	if malformedEventError == nil && share.BelongsToOperator(eh.operatorData.GetOperatorData().ID) {
 		if shareSecret == nil {
 			return nil, errors.New("could not decode shareSecret")
 		}
@@ -253,7 +265,7 @@
 		return nil, fmt.Errorf("could not save validator share: %w", err)
 	}
 
-	return share, nil
+	return share, malformedEventError
 }
 
 func validatorAddedEventToShare(
@@ -301,18 +313,21 @@
 		shareSecret = &bls.SecretKey{}
 		decryptedSharePrivateKey, err := rsaencryption.DecodeKey(operatorPrivateKey, encryptedKeys[i])
 		if err != nil {
-			return nil, nil, &MalformedEventError{
-				Err: fmt.Errorf("could not decrypt share private key: %w", err),
+			return &validatorShare, nil, &MalformedEventError{
+				Err:                     fmt.Errorf("could not decrypt share private key: %w", err),
+				IsInvalidEncryptedShare: true,
 			}
 		}
 		if err = shareSecret.SetHexString(string(decryptedSharePrivateKey)); err != nil {
-			return nil, nil, &MalformedEventError{
-				Err: fmt.Errorf("could not set decrypted share private key: %w", err),
+			return &validatorShare, nil, &MalformedEventError{
+				Err:                     fmt.Errorf("could not set decrypted share private key: %w", err),
+				IsInvalidEncryptedShare: true,
 			}
 		}
 		if !bytes.Equal(shareSecret.GetPublicKey().Serialize(), validatorShare.SharePubKey) {
-			return nil, nil, &MalformedEventError{
-				Err: errors.New("share private key does not match public key"),
+			return &validatorShare, nil, &MalformedEventError{
+				Err:                     fmt.Errorf("share private key does not match public key"),
+				IsInvalidEncryptedShare: true,
 			}
 		}
 	}
@@ -321,6 +336,7 @@
 	validatorShare.DomainType = ssvtypes.GetDefaultDomain()
 	validatorShare.Committee = committee
 	validatorShare.Graffiti = []byte("ssv.network")
+	validatorShare.Metadata.Invalid = false
 
 	return &validatorShare, shareSecret, nil
 }
@@ -520,7 +536,8 @@
 
 // MalformedEventError is returned when event is malformed
 type MalformedEventError struct {
-	Err error
+	Err                     error
+	IsInvalidEncryptedShare bool
 }
 
 func (e *MalformedEventError) Error() string {

protocol/v2/types/ssvshare.go

@@ -103,4 +103,5 @@ type Metadata struct {
 	BeaconMetadata *beaconprotocol.ValidatorMetadata
 	OwnerAddress   common.Address
 	Liquidated     bool
+	Invalid        bool
 }