Eos siging

Makefile

@@ -3,10 +3,11 @@ PROTOC = protoc --plugin=./protoc-gen-gogo -I$(GOPATH)/src -I/usr/local/include
 GOGO_PROTOBUF_DIR = $(GOPATH)/src/github.com/gogo/protobuf
 HASHICORP_DIR = $(GOPATH)/src/github.com/hashicorp/go-plugin
 GETH_DIR = $(GOPATH)/src/github.com/ethereum/go-ethereum
+EOS_DIR = $(GOPATH)/src/github.com/eosspark/eos-go
 SSHA3_DIR = $(GOPATH)/src/github.com/miguelmota/go-solidity-sha3
 # This commit sha should match the one in loomchain repo
 GETH_GIT_REV = 1fb6138d017a4309105d91f187c126cf979c93f9
-
+EOS_GIT_REV = 2a0f2243770a4ca745ebe30d0594a76e135d6a4d
 .PHONY: all evm examples get_lint update_lint example-cli evmexample-cli example-plugins example-plugins-external plugins proto test lint deps clean test-evm deps-evm deps-all lint
 
 all: examples
@@ -101,6 +102,9 @@ $(SSHA3_DIR):
 $(GETH_DIR):
 	git clone -q https://github.com/loomnetwork/go-ethereum.git $@
 
+$(EOS_DIR):
+	git clone -q https://github.com/eosspark/eos-go.git $@
+
 deps-all: deps deps-evm
 
 deps:
@@ -121,8 +125,9 @@ deps:
 	cd $(GOGO_PROTOBUF_DIR) && git checkout v1.1.1
 	cd $(HASHICORP_DIR) && git checkout f4c3476bd38585f9ec669d10ed1686abd52b9961
 
-deps-evm: $(SSHA3_DIR) $(GETH_DIR)
+deps-evm: $(SSHA3_DIR) $(GETH_DIR) $(EOS_DIR)
 	cd $(GETH_DIR) && git checkout master && git pull && git checkout $(GETH_GIT_REV)
+	cd $(EOS_DIR) && git checkout master && git pull && git checkout $(EOS_GIT_REV)
 	go get \
 		github.com/loomnetwork/yubihsm-go \
 		gopkg.in/check.v1

auth/eos-signer.go

@@ -0,0 +1,52 @@
+// +build evm
+
+package auth
+
+import (
+	"crypto/ecdsa"
+	"crypto/sha256"
+	"encoding/hex"
+	"strconv"
+	"strings"
+
+	"github.com/eosspark/eos-go/crypto/ecc"
+	"github.com/ethereum/go-ethereum/crypto"
+	"github.com/gogo/protobuf/proto"
+	"github.com/loomnetwork/go-loom/common/evmcompat"
+)
+
+type EosSigner struct {
+	PrivateKey *ecc.PrivateKey
+}
+
+func (e *EosSigner) Sign(txBytes []byte) []byte {
+	hash := sha256.Sum256([]byte(strings.ToUpper(hex.EncodeToString(txBytes))))
+	var nonceTx NonceTx
+	if err := proto.Unmarshal(txBytes, &nonceTx); err != nil {
+		panic(err)
+	}
+	typedSignature := []byte{byte(evmcompat.SignatureType_EOS)}
+
+	nonceBytes := []byte(strconv.FormatUint(nonceTx.Sequence, 10))[:6]
+	typedSignature = append(typedSignature, nonceBytes...)
+
+	nonceHash := sha256.Sum256([]byte(hex.EncodeToString(nonceBytes)))
+	scatterMsgHash := sha256.Sum256([]byte(hex.EncodeToString(hash[:]) + hex.EncodeToString(nonceHash[:])))
+
+	signature, err := e.PrivateKey.Sign(scatterMsgHash[:])
+	if err != nil {
+		panic(err)
+	}
+	typedSignature = append(typedSignature, []byte(signature.String())...)
+
+	return typedSignature
+}
+
+func (e *EosSigner) PublicKey() []byte {
+	btcecPubKey, err := e.PrivateKey.PublicKey().Key()
+	if err != nil {
+		panic(err)
+	}
+	ecdsaPubKey := ecdsa.PublicKey(*btcecPubKey)
+	return crypto.FromECDSAPub(&ecdsaPubKey)
+}

auth/no-evm.go

@@ -5,6 +5,7 @@ package auth
 import (
 	"crypto/ecdsa"
 	"fmt"
+	"github.com/eosspark/eos-go/crypto/ecc"
 )
 
 func GetTxHash(_ []byte) ([]byte, error) {
@@ -38,3 +39,15 @@ func (k *TronSigner) Sign(_ []byte) []byte {
 func (k *TronSigner) PublicKey() []byte {
 	return nil
 }
+
+type EosSigner struct {
+	PrivateKey *ecc.PrivateKey
+}
+
+func (k *EosSigner) Sign(_ []byte) []byte {
+	return nil
+}
+
+func (k *EosSigner) PublicKey() []byte {
+	return nil
+}

common/evmcompat/helpers.go

@@ -5,14 +5,17 @@ package evmcompat
 import (
 	"bytes"
 	"crypto/ecdsa"
+	"crypto/sha256"
 	"encoding/binary"
 	"encoding/hex"
-	"errors"
 	"fmt"
 	"math/big"
 	"strconv"
 	"strings"
 
+	"github.com/pkg/errors"
+
+	"github.com/eosspark/eos-go/crypto/ecc"
 	"github.com/ethereum/go-ethereum/common"
 	"github.com/ethereum/go-ethereum/crypto"
 	"github.com/ethereum/go-ethereum/crypto/sha3"
@@ -22,9 +25,10 @@ import (
 type SignatureType uint8
 
 const (
-	SignatureType_EIP712 SignatureType = 0
-	SignatureType_GETH   SignatureType = 1
-	SignatureType_TREZOR SignatureType = 2
+	SignatureType_EIP712 SignatureType = iota
+	SignatureType_GETH
+	SignatureType_TREZOR
+	SignatureType_EOS
 )
 
 // SoliditySign signs the given data with the specified private key and returns the 65-byte signature.
@@ -78,30 +82,78 @@ func GenerateTypedSig(data []byte, privKey *ecdsa.PrivateKey, sigType SignatureT
 // RecoverAddressFromTypedSig recovers the Ethereum address from a signed hash and a 66-byte signature
 // (the first byte of which is expected to denote the SignatureType).
 func RecoverAddressFromTypedSig(hash []byte, sig []byte) (common.Address, error) {
-	var signer common.Address
-
-	if len(sig) != 66 {
-		return signer, fmt.Errorf("signature must be 66 bytes, not %d bytes", len(sig))
-	}
+	var err error
 
 	switch SignatureType(sig[0]) {
 	case SignatureType_EIP712:
+		err = recoverAddressFromEIP712(sig[1:])
 	case SignatureType_GETH:
-		hash = ssha.SoliditySHA3(
-			ssha.String("\x19Ethereum Signed Message:\n32"),
-			ssha.Bytes32(hash),
-		)
+		hash, err = recoverAddressFromGeth(hash, sig[1:])
 	case SignatureType_TREZOR:
-		hash = ssha.SoliditySHA3(
-			ssha.String("\x19Ethereum Signed Message:\n\x20"),
-			ssha.Bytes32(hash),
-		)
+		hash, err = recoverAddressFromTrezor(hash, sig[1:])
+	case SignatureType_EOS:
+		return recoverAddressFromEos(hash, sig[1:])
 	default:
-		return signer, fmt.Errorf("invalid signature type: %d", sig[0])
+		err = fmt.Errorf("invalid signature type: %d", sig[0])
+	}
+	if err != nil {
+		return common.Address{}, err
+	}
+
+	return SolidityRecover(hash, sig[1:])
+}
+
+func recoverAddressFromEIP712(sig []byte) error {
+	if len(sig) != 65 {
+		return fmt.Errorf("signature must be 66 bytes, not %d bytes", len(sig))
+	}
+	return nil
+}
+
+func recoverAddressFromGeth(hash []byte, sig []byte) ([]byte, error) {
+	if len(sig) != 65 {
+		return nil, fmt.Errorf("signature must be 66 bytes, not %d bytes", len(sig))
 	}
+	return ssha.SoliditySHA3(
+		ssha.String("\x19Ethereum Signed Message:\n32"),
+		ssha.Bytes32(hash),
+	), nil
+}
 
-	signer, err := SolidityRecover(hash, sig[1:])
-	return signer, err
+func recoverAddressFromTrezor(hash []byte, sig []byte) ([]byte, error) {
+	if len(sig) != 65 {
+		return nil, fmt.Errorf("signature must be 66 bytes, not %d bytes", len(sig))
+	}
+	return ssha.SoliditySHA3(
+		ssha.String("\x19Ethereum Signed Message:\n\x20"),
+		ssha.Bytes32(hash),
+	), nil
+}
+
+func recoverAddressFromEos(hash []byte, sig []byte) (common.Address, error) {
+	var signer common.Address
+
+	if len(sig) != 107 {
+		return signer, fmt.Errorf("eos signature must be 107 bytes, not %d bytes", len(sig))
+	}
+	signature, err := ecc.NewSignature(string(sig[6:]))
+	if err != nil {
+		return signer, fmt.Errorf("cannot unpack eos signature %v", string(sig))
+	}
+
+	nonceHash := sha256.Sum256([]byte(hex.EncodeToString(sig[:6])))
+	scatterMsgHash := sha256.Sum256([]byte(hex.EncodeToString(hash) + hex.EncodeToString(nonceHash[:])))
+
+	pubKey, err := signature.PublicKey(scatterMsgHash[:])
+	if err != nil {
+		return signer, fmt.Errorf("cannot get publlic key from hash %v", string(hash))
+	}
+	btcecPubKey, err := pubKey.Key()
+	if err != nil {
+		return signer, errors.Wrapf(err, "retrieve btcec key from eos key %v", pubKey)
+	}
+	local := crypto.PubkeyToAddress(ecdsa.PublicKey(*btcecPubKey))
+	return local, nil
 }
 
 //TODO in future all interfaces and not do conversions from strings