retry v value, and and deviceID in require param (#766)

Author: huangzhiran

e2e/util.go

@@ -27,6 +27,7 @@ import (
 
 func signMesssage(data []byte, projectID uint64, key *ecdsa.PrivateKey) ([]byte, error) {
 	req := &api.CreateTaskReq{
+		DeviceID:  "did:io:" + crypto.PubkeyToAddress(key.PublicKey).String(),
 		Nonce:     uint64(time.Now().Unix()),
 		ProjectID: strconv.Itoa(int(projectID)),
 		Payloads:  []string{hexutil.Encode(data)},
@@ -42,6 +43,7 @@ func signMesssage(data []byte, projectID uint64, key *ecdsa.PrivateKey) ([]byte,
 	if err != nil {
 		return nil, err
 	}
+	sig = sig[:len(sig)-1]
 
 	req.Signature = hexutil.Encode(sig)
 

service/apinode/api/http.go

@@ -35,6 +35,7 @@ func newErrResp(err error) *errResp {
 
 type CreateTaskReq struct {
 	Nonce          uint64   `json:"nonce"                        binding:"required"`
+	DeviceID       string   `json:"deviceID"                     binding:"required"`
 	ProjectID      string   `json:"projectID"                    binding:"required"`
 	ProjectVersion string   `json:"projectVersion,omitempty"`
 	Payloads       []string `json:"payloads"                     binding:"required"`
@@ -88,13 +89,13 @@ func (s *httpServer) createTask(c *gin.Context) {
 		c.JSON(http.StatusBadRequest, newErrResp(errors.Wrap(err, "failed to decode signature from hex format")))
 		return
 	}
-	pubkey, alg, err := recoverPubkey(*req, sig)
+	deviceAddr := common.HexToAddress(strings.TrimPrefix(req.DeviceID, "did:io:"))
+	addr, sig, alg, err := recoverAddr(*req, sig, deviceAddr)
 	if err != nil {
 		slog.Error("failed to recover public key", "error", err)
 		c.JSON(http.StatusBadRequest, newErrResp(errors.Wrap(err, "invalid signature; could not recover public key")))
 		return
 	}
-	addr := crypto.PubkeyToAddress(*pubkey)
 
 	ok, err := s.db.IsDeviceApproved(pid, addr)
 	if err != nil {
@@ -174,24 +175,40 @@ func (s *httpServer) createTask(c *gin.Context) {
 	})
 }
 
-func recoverPubkey(req CreateTaskReq, sig []byte) (*ecdsa.PublicKey, string, error) {
+func recoverAddr(req CreateTaskReq, sig []byte, deviceAddr common.Address) (common.Address, []byte, string, error) {
 	req.Signature = ""
 	reqJson, err := json.Marshal(req)
 	if err != nil {
-		return nil, "", errors.Wrap(err, "failed to marshal request into json format")
+		return common.Address{}, nil, "", errors.Wrap(err, "failed to marshal request into json format")
 	}
 
 	switch req.Algorithm {
 	default:
-		hash := sha256.New()
-		hash.Write(reqJson)
-		h := hash.Sum(nil)
+		h := sha256.Sum256(reqJson)
+		res := []struct {
+			pk  *ecdsa.PublicKey
+			sig []byte
+		}{}
+		rID := []uint8{0, 1}
+		for _, id := range rID {
+			ns := append(sig, byte(id))
+			if pk, err := crypto.SigToPub(h[:], ns); err != nil {
+				slog.Debug("failed to recover public key from signature", "error", err, "recover_id", id, "signature", hexutil.Encode(sig))
+			} else {
+				res = append(res, struct {
+					pk  *ecdsa.PublicKey
+					sig []byte
+				}{pk: pk, sig: ns})
+			}
+		}
 
-		pk, err := crypto.SigToPub(h, sig)
-		if err != nil {
-			return nil, "", errors.Wrap(err, "failed to recover public key from signature")
+		for _, r := range res {
+			addr := crypto.PubkeyToAddress(*r.pk)
+			if bytes.Equal(addr.Bytes(), deviceAddr.Bytes()) {
+				return addr, r.sig, "ES256", nil
+			}
 		}
-		return pk, "ES256", nil
+		return common.Address{}, nil, "", errors.New("failed to recover public key from signature")
 	}
 }