Reject conficting challenge registrations

rpc/rpcserver.go

@@ -78,6 +78,8 @@ func (r *rpcServer) Submit(ctx context.Context, in *api.SubmitRequest) (*api.Sub
 		return nil, status.Error(codes.InvalidArgument, err.Error())
 	case errors.Is(err, service.ErrMaxMembersReached):
 		return nil, status.Error(codes.ResourceExhausted, err.Error())
+	case errors.Is(err, service.ErrConflictingRegistration):
+		return nil, status.Error(codes.AlreadyExists, err.Error())
 	case err != nil:
 		logging.FromContext(ctx).Warn("unknown error submitting challenge", zap.Error(err))
 		return nil, status.Error(codes.Internal, "unknown error submitting challenge")

server/server_test.go

@@ -325,6 +325,48 @@ func TestCannotSubmitMoreThanMaxRoundMembers(t *testing.T) {
 	req.NoError(eg.Wait())
 }
 
+// Test if cannot submit two different challenges with the same nodeID.
+func TestSubmittingChallengeTwice(t *testing.T) {
+	t.Parallel()
+	req := require.New(t)
+	ctx, cancel := context.WithCancel(context.Background())
+	defer cancel()
+
+	cfg := config.DefaultConfig()
+	cfg.PoetDir = t.TempDir()
+	cfg.RawRPCListener = randomHost
+	cfg.RawRESTListener = randomHost
+
+	srv, client := spawnPoet(ctx, t, *cfg)
+
+	var eg errgroup.Group
+	eg.Go(func() error {
+		return srv.Start(ctx)
+	})
+
+	pubKey, privKey, err := ed25519.GenerateKey(rand.Reader)
+	req.NoError(err)
+
+	submitChallenge := func(ch []byte) error {
+		_, err = client.Submit(context.Background(), &api.SubmitRequest{
+			Challenge: ch,
+			Pubkey:    pubKey,
+			Signature: ed25519.Sign(privKey, ch),
+		})
+		return err
+	}
+
+	// Act
+	req.NoError(submitChallenge([]byte("challenge 1")))
+	// Submitting the same challenge is OK
+	req.NoError(submitChallenge([]byte("challenge 1")))
+	// Submitting a different challenge with the same nodeID is not OK
+	req.ErrorIs(
+		submitChallenge([]byte("challenge 2")),
+		status.Error(codes.AlreadyExists, service.ErrConflictingRegistration.Error()),
+	)
+}
+
 func TestGettingInitialPowParams(t *testing.T) {
 	t.Parallel()
 	req := require.New(t)

service/round.go

@@ -1,6 +1,7 @@
 package service
 
 import (
+	"bytes"
 	"context"
 	"errors"
 	"fmt"
@@ -128,17 +129,26 @@
 		return ErrMaxMembersReached
 	}
 
-	if has, err := r.challengesDb.Has(key, nil); err != nil {
-		return err
-	} else if has {
+	registered, err := r.challengesDb.Get(key, nil)
+	switch {
+	case errors.Is(err, leveldb.ErrNotFound):
+		// OK - challenge is not registered yet.
+	case err != nil:
+		return fmt.Errorf("failed to check if challenge is registered: %w", err)
+	case bytes.Equal(challenge, registered):
 		return fmt.Errorf("%w: key: %X", ErrChallengeAlreadySubmitted, key)
+	default:
+		return ErrConflictingRegistration
 	}
-	err := r.challengesDb.Put(key, challenge, &opt.WriteOptions{Sync: true})
-	if err == nil {
-		r.members += 1
-		r.membersCounter.Inc()
+
+	if err := r.challengesDb.Put(key, challenge, &opt.WriteOptions{Sync: true}); err != nil {
+		return fmt.Errorf("failed to register challenge: %w", err)
 	}
-	return err
+
+	r.members += 1
+	r.membersCounter.Inc()
+
+	return nil
 }
 
 func (r *round) execute(ctx context.Context, end time.Time, minMemoryLayer, fileWriterBufSize uint) error {

service/round_test.go

@@ -165,10 +165,14 @@ func TestRound_Submit(t *testing.T) {
 
 		// Act
 		require.NoError(t, round.submit(context.Background(), []byte("key"), challenges[0]))
+
+		err = round.submit(context.Background(), []byte("key"), challenges[0])
+		require.ErrorIs(t, err, ErrChallengeAlreadySubmitted)
+
 		err = round.submit(context.Background(), []byte("key"), challenges[1])
+		require.ErrorIs(t, err, ErrConflictingRegistration)
 
 		// Verify
-		require.ErrorIs(t, err, ErrChallengeAlreadySubmitted)
 		require.Equal(t, 1, numChallenges(round))
 		challenge, err := round.challengesDb.Get([]byte("key"), nil)
 		require.NoError(t, err)

service/service.go

@@ -96,6 +96,7 @@ var (
 	ErrNotStarted                = errors.New("service not started")
 	ErrAlreadyStarted            = errors.New("already started")
 	ErrChallengeAlreadySubmitted = errors.New("challenge is already submitted")
+	ErrConflictingRegistration   = errors.New("conflicting registration")
 	ErrRoundNotFinished          = errors.New("round is not finished yet")
 )