Fix timeout (#33)

* bump timeout

* embracing asynchronicity

impl/pkg/server/pkarr.go

@@ -115,7 +115,7 @@ func (r *PKARRRouter) PutRecord(c *gin.Context) {
 		Sig: sigBytes,
 		Seq: seq,
 	}
-	if _, err = r.service.PublishPKARR(c, request); err != nil {
+	if err = r.service.PublishPKARR(c, request); err != nil {
 		LoggingRespondErrWithMsg(c, err, "failed to publish pkarr record", http.StatusInternalServerError)
 		return
 	}

impl/pkg/server/server.go

@@ -64,9 +64,9 @@ func NewServer(cfg *config.Config, shutdown chan os.Signal) (*Server, error) {
 		Server: &http.Server{
 			Addr:              fmt.Sprintf("%s:%d", cfg.ServerConfig.APIHost, cfg.ServerConfig.APIPort),
 			Handler:           handler,
-			ReadTimeout:       time.Second * 5,
-			ReadHeaderTimeout: time.Second * 5,
-			WriteTimeout:      time.Second * 5,
+			ReadTimeout:       time.Second * 15,
+			ReadHeaderTimeout: time.Second * 15,
+			WriteTimeout:      time.Second * 15,
 		},
 		cfg:      cfg,
 		svc:      pkarrService,

impl/pkg/service/pkarr.go

@@ -3,6 +3,7 @@ package service
 import (
 	"context"
 	"encoding/base64"
+	"errors"
 
 	"github.com/TBD54566975/ssi-sdk/util"
 	"github.com/anacrolix/dht/v2/bep44"
@@ -56,6 +57,23 @@ type PublishPKARRRequest struct {
 	Seq int64    `validate:"required"`
 }
 
+// isValid returns an error if the request is invalid
+// also validates the signature
+func (p PublishPKARRRequest) isValid() error {
+	if err := util.IsValidStruct(p); err != nil {
+		return err
+	}
+	// validate the signature
+	bv, err := bencode.Marshal(p.V)
+	if err != nil {
+		return err
+	}
+	if !bep44.Verify(p.K[:], nil, p.Seq, bv, p.Sig[:]) {
+		return errors.New("signature is invalid")
+	}
+	return nil
+}
+
 func (p PublishPKARRRequest) toRecord() storage.PKARRRecord {
 	encoding := base64.RawURLEncoding
 	return storage.PKARRRecord{
@@ -67,20 +85,25 @@ func (p PublishPKARRRequest) toRecord() storage.PKARRRecord {
 }
 
 // PublishPKARR stores the record in the db, publishes the given PKARR to the DHT, and returns the z-base-32 encoded ID
-func (s *PKARRService) PublishPKARR(ctx context.Context, request PublishPKARRRequest) (string, error) {
-	if err := util.IsValidStruct(request); err != nil {
-		return "", err
+func (s *PKARRService) PublishPKARR(ctx context.Context, request PublishPKARRRequest) error {
+	if err := request.isValid(); err != nil {
+		return err
 	}
+
 	// TODO(gabe): if putting to the DHT fails we should note that in the db and retry later
 	if err := s.db.WriteRecord(request.toRecord()); err != nil {
-		return "", err
+		return err
 	}
-	return s.dht.Put(ctx, bep44.Put{
+
+	// return here and put it in the DHT asynchronously
+	go s.dht.Put(ctx, bep44.Put{
 		V:   request.V,
 		K:   &request.K,
 		Sig: request.Sig,
 		Seq: request.Seq,
 	})
+
+	return nil
 }
 
 // GetPKARRResponse is the response to a get PKARR request

impl/pkg/service/pkarr_test.go

@@ -18,7 +18,7 @@ func TestPKARRService(t *testing.T) {
 	require.NotEmpty(t, svc)
 
 	t.Run("test put bad record", func(t *testing.T) {
-		_, err := svc.PublishPKARR(context.Background(), PublishPKARRRequest{})
+		err := svc.PublishPKARR(context.Background(), PublishPKARRRequest{})
 		assert.Error(t, err)
 		assert.Contains(t, err.Error(), "validation for 'V' failed on the 'required' tag")
 	})
@@ -29,30 +29,68 @@ func TestPKARRService(t *testing.T) {
 		assert.Nil(t, got)
 	})
 
+	t.Run("test record with a bad signature", func(t *testing.T) {
+		// create a did doc as a packet to store
+		sk, doc, err := did.GenerateDIDDHT(did.CreateDIDDHTOpts{})
+		require.NoError(t, err)
+		require.NotEmpty(t, doc)
+
+		d := did.DHT(doc.ID)
+		packet, err := d.ToDNSPacket(*doc, nil)
+		assert.NoError(t, err)
+		assert.NotEmpty(t, packet)
+
+		putMsg, err := dht.CreatePKARRPublishRequest(sk, *packet)
+		require.NoError(t, err)
+		require.NotEmpty(t, putMsg)
+
+		err = svc.PublishPKARR(context.Background(), PublishPKARRRequest{
+			V:   putMsg.V.([]byte),
+			K:   *putMsg.K,
+			Sig: putMsg.Sig,
+			Seq: putMsg.Seq,
+		})
+		assert.NoError(t, err)
+
+		// invalidate the signature
+		putMsg.Sig[0] = 0
+		err = svc.PublishPKARR(context.Background(), PublishPKARRRequest{
+			V:   putMsg.V.([]byte),
+			K:   *putMsg.K,
+			Sig: putMsg.Sig,
+			Seq: putMsg.Seq,
+		})
+		assert.Error(t, err)
+		assert.Contains(t, err.Error(), "signature is invalid")
+	})
+
 	t.Run("test put and get record", func(t *testing.T) {
 		// create a did doc as a packet to store
 		sk, doc, err := did.GenerateDIDDHT(did.CreateDIDDHTOpts{})
 		require.NoError(t, err)
 		require.NotEmpty(t, doc)
 
-		packet, err := did.DHT(doc.ID).ToDNSPacket(*doc, nil)
+		d := did.DHT(doc.ID)
+		packet, err := d.ToDNSPacket(*doc, nil)
 		assert.NoError(t, err)
 		assert.NotEmpty(t, packet)
 
 		putMsg, err := dht.CreatePKARRPublishRequest(sk, *packet)
 		require.NoError(t, err)
 		require.NotEmpty(t, putMsg)
 
-		id, err := svc.PublishPKARR(context.Background(), PublishPKARRRequest{
+		err = svc.PublishPKARR(context.Background(), PublishPKARRRequest{
 			V:   putMsg.V.([]byte),
 			K:   *putMsg.K,
 			Sig: putMsg.Sig,
 			Seq: putMsg.Seq,
 		})
 		assert.NoError(t, err)
-		assert.NotEmpty(t, id)
 
-		got, err := svc.GetPKARR(context.Background(), id)
+		suffix, err := d.Suffix()
+		assert.NoError(t, err)
+
+		got, err := svc.GetPKARR(context.Background(), suffix)
 		assert.NoError(t, err)
 		assert.NotEmpty(t, got)
 		assert.Equal(t, putMsg.V, got.V)