synapsecns/sanguine

package rest

import (
    "crypto/ecdsa"
    "fmt"
    "net/http"
    "strconv"
    "strings"

    "github.com/ethereum/go-ethereum/common"
    "github.com/ethereum/go-ethereum/common/hexutil"
    "github.com/ethereum/go-ethereum/crypto"
    "github.com/gin-gonic/gin"
)

// EIP191Auth implements ethereum signed message authentication middleware for gin rest api
// For auth, relayer should pass in eth signed message following eip-191 with the message
// as the current unix timestamp in seconds
// i.e. signature (hex encoded) = keccak(bytes.concat("\x19Ethereum Signed Message:\n", len(strconv.Itoa(time.Now().Unix()), strconv.Itoa(time.Now().Unix())))
// so that full auth header string: auth = strconv.Itoa(time.Now().Unix()) + ":" + signature
// see: https://ethereum.org/en/developers/docs/apis/json-rpc/#eth_sign
func EIP191Auth(c *gin.Context, deadline int64) (accountRecovered common.Address, err error) {
    auth := c.Request.Header.Get(AuthorizationHeader)

    // parse <timestamp>:<signature>
    s := strings.Split(auth, ":")
    if len(s) != 2 {
        err = fmt.Errorf("invalid authorization header format")
        c.JSON(http.StatusBadRequest, gin.H{"msg": err})
        return common.Address{}, err
    }

    // check timestamp is not older than given deadline
    var timestamp int64
    timestamp, err = strconv.ParseInt(s[0], 10, 64)
    if err != nil {
        err = fmt.Errorf("invalid timestamp in authorization")
        c.JSON(http.StatusBadRequest, gin.H{"msg": err})
        return common.Address{}, err
    } else if timestamp < deadline {
        err = fmt.Errorf("authorization too old")
        c.JSON(http.StatusUnauthorized, gin.H{"msg": err}) // Unauthorized
        return common.Address{}, err
    }

    // check signature matches eth signed data of timestamp signed by given account
    var signature []byte
    signature, err = hexutil.Decode(s[1])
    if err != nil {
        err = fmt.Errorf("signature not hex encoded in authorization")
        c.JSON(http.StatusBadRequest, gin.H{"msg": err})
        return common.Address{}, err
    }

    data := "\x19Ethereum Signed Message:\n" + strconv.Itoa(len(s[0])) + s[0]
    digest := crypto.Keccak256([]byte(data)) // TODO: check []byte(data) ok

    // identify byte position of the recovery ID ("v")
    vIndex := len(signature) - 1

    // Ethereum signatures commonly use v values of 27 or 28 for EIP-191.
    // Some libraries may return v as 0 or 1, so we need to handle both cases. crypto.SigToPub expects 0/1
    switch signature[vIndex] {
    //nolint: mnd
    case 27, 28:
        signature[vIndex] -= 27 // Normalize to 0 or 1 for crypto.SigToPub
    //nolint: mnd
    case 0, 1:
        // do nothing, already normalized
    default:
        err = fmt.Errorf("unrecognized recovery ID value - expected 0, 1, 27, or 28")
        c.JSON(http.StatusBadRequest, gin.H{"msg": err})
        return common.Address{}, err
    }

    var recovered *ecdsa.PublicKey
    recovered, err = crypto.SigToPub(digest, signature)
    if err != nil {
        err = fmt.Errorf("failed to recover signer from authorization")
        c.JSON(http.StatusBadRequest, gin.H{"msg": err})
        return common.Address{}, err
    }

    signer := crypto.PubkeyToAddress(*recovered)

    return signer, nil
}