native: implement CryptoLib contract

pkg/core/native/contract.go

@@ -24,6 +24,7 @@ type Contracts struct {
 	Designate   *Designate
 	NameService *NameService
 	Notary      *Notary
+	Crypto      *Crypto
 	Contracts   []interop.Contract
 	// persistScript is vm script which executes "onPersist" method of every native contract.
 	persistScript []byte
@@ -61,6 +62,10 @@ func NewContracts(p2pSigExtensionsEnabled bool) *Contracts {
 	cs.Management = mgmt
 	cs.Contracts = append(cs.Contracts, mgmt)
 
+	c := newCrypto()
+	cs.Crypto = c
+	cs.Contracts = append(cs.Contracts, c)
+
 	ledger := newLedger()
 	cs.Ledger = ledger
 	cs.Contracts = append(cs.Contracts, ledger)

pkg/core/native/crypto.go

@@ -0,0 +1,138 @@
+package native
+
+import (
+	"crypto/elliptic"
+	"errors"
+	"fmt"
+
+	"github.com/btcsuite/btcd/btcec"
+	"github.com/nspcc-dev/neo-go/pkg/core/interop"
+	"github.com/nspcc-dev/neo-go/pkg/core/native/nativenames"
+	"github.com/nspcc-dev/neo-go/pkg/crypto/hash"
+	"github.com/nspcc-dev/neo-go/pkg/crypto/keys"
+	"github.com/nspcc-dev/neo-go/pkg/smartcontract"
+	"github.com/nspcc-dev/neo-go/pkg/smartcontract/callflag"
+	"github.com/nspcc-dev/neo-go/pkg/smartcontract/manifest"
+	"github.com/nspcc-dev/neo-go/pkg/vm/stackitem"
+)
+
+// Crypto represents CryptoLib contract.
+type Crypto struct {
+	interop.ContractMD
+}
+
+// NamedCurve identifies named elliptic curves.
+type NamedCurve byte
+
+// Various named elliptic curves.
+const (
+	Secp256k1 NamedCurve = 22
+	Secp256r1 NamedCurve = 23
+)
+
+const cryptoContractID = -3
+
+func newCrypto() *Crypto {
+	c := &Crypto{ContractMD: *interop.NewContractMD(nativenames.CryptoLib, cryptoContractID)}
+	defer c.UpdateHash()
+
+	desc := newDescriptor("sha256", smartcontract.ByteArrayType,
+		manifest.NewParameter("data", smartcontract.ByteArrayType))
+	md := newMethodAndPrice(c.sha256, 1<<15, callflag.NoneFlag)
+	c.AddMethod(md, desc)
+
+	desc = newDescriptor("ripemd160", smartcontract.ByteArrayType,
+		manifest.NewParameter("data", smartcontract.ByteArrayType))
+	md = newMethodAndPrice(c.ripemd160, 1<<15, callflag.NoneFlag)
+	c.AddMethod(md, desc)
+
+	desc = newDescriptor("verifyWithECDsa", smartcontract.BoolType,
+		manifest.NewParameter("message", smartcontract.ByteArrayType),
+		manifest.NewParameter("pubkey", smartcontract.ByteArrayType),
+		manifest.NewParameter("signature", smartcontract.ByteArrayType),
+		manifest.NewParameter("curve", smartcontract.IntegerType))
+	md = newMethodAndPrice(c.verifyWithECDsa, 1<<15, callflag.NoneFlag)
+	c.AddMethod(md, desc)
+	return c
+}
+
+func (c *Crypto) sha256(_ *interop.Context, args []stackitem.Item) stackitem.Item {
+	bs, err := args[0].TryBytes()
+	if err != nil {
+		panic(err)
+	}
+	return stackitem.NewByteArray(hash.Sha256(bs).BytesBE())
+}
+
+func (c *Crypto) ripemd160(_ *interop.Context, args []stackitem.Item) stackitem.Item {
+	bs, err := args[0].TryBytes()
+	if err != nil {
+		panic(err)
+	}
+	return stackitem.NewByteArray(hash.RipeMD160(bs).BytesBE())
+}
+
+func (c *Crypto) verifyWithECDsa(_ *interop.Context, args []stackitem.Item) stackitem.Item {
+	msg, err := args[0].TryBytes()
+	if err != nil {
+		panic(fmt.Errorf("invalid message stackitem: %w", err))
+	}
+	hashToCheck := hash.Sha256(msg)
+	pubkey, err := args[1].TryBytes()
+	if err != nil {
+		panic(fmt.Errorf("invalid pubkey stackitem: %w", err))
+	}
+	signature, err := args[2].TryBytes()
+	if err != nil {
+		panic(fmt.Errorf("invalid signature stackitem: %w", err))
+	}
+	curve, err := curveFromStackitem(args[3])
+	if err != nil {
+		panic(fmt.Errorf("invalid curve stackitem: %w", err))
+	}
+	pkey, err := keys.NewPublicKeyFromBytes(pubkey, curve)
+	if err != nil {
+		panic(fmt.Errorf("failed to decode pubkey: %w", err))
+	}
+	res := pkey.Verify(signature, hashToCheck.BytesBE())
+	return stackitem.NewBool(res)
+}
+
+func curveFromStackitem(si stackitem.Item) (elliptic.Curve, error) {
+	curve, err := si.TryInteger()
+	if err != nil {
+		return nil, err
+	}
+	if !curve.IsInt64() {
+		return nil, errors.New("not an int64")
+	}
+	c := curve.Int64()
+	switch c {
+	case int64(Secp256k1):
+		return btcec.S256(), nil
+	case int64(Secp256r1):
+		return elliptic.P256(), nil
+	default:
+		return nil, errors.New("unsupported curve type")
+	}
+}
+
+// Metadata implements Contract interface.
+func (c *Crypto) Metadata() *interop.ContractMD {
+	return &c.ContractMD
+}
+
+// Initialize implements Contract interface.
+func (c *Crypto) Initialize(ic *interop.Context) error {
+	return nil
+}
+
+// OnPersist implements Contract interface.
+func (c *Crypto) OnPersist(ic *interop.Context) error {
+	return nil
+}
+
+// PostPersist implements Contract interface.
+func (c *Crypto) PostPersist(ic *interop.Context) error {
+	return nil
+}

pkg/core/native/crypto_test.go

@@ -0,0 +1,41 @@
+package native
+
+import (
+	"encoding/hex"
+	"testing"
+
+	"github.com/nspcc-dev/neo-go/pkg/core/interop"
+	"github.com/nspcc-dev/neo-go/pkg/vm"
+	"github.com/nspcc-dev/neo-go/pkg/vm/stackitem"
+	"github.com/stretchr/testify/require"
+)
+
+func TestSha256(t *testing.T) {
+	c := newCrypto()
+	ic := &interop.Context{VM: vm.New()}
+
+	t.Run("bad arg type", func(t *testing.T) {
+		require.Panics(t, func() {
+			c.sha256(ic, []stackitem.Item{stackitem.NewInterop(nil)})
+		})
+	})
+	t.Run("good", func(t *testing.T) {
+		// 0x0100 hashes to 47dc540c94ceb704a23875c11273e16bb0b8a87aed84de911f2133568115f254
+		require.Equal(t, "47dc540c94ceb704a23875c11273e16bb0b8a87aed84de911f2133568115f254", hex.EncodeToString(c.sha256(ic, []stackitem.Item{stackitem.NewByteArray([]byte{1, 0})}).Value().([]byte)))
+	})
+}
+
+func TestRIPEMD160(t *testing.T) {
+	c := newCrypto()
+	ic := &interop.Context{VM: vm.New()}
+
+	t.Run("bad arg type", func(t *testing.T) {
+		require.Panics(t, func() {
+			c.ripemd160(ic, []stackitem.Item{stackitem.NewInterop(nil)})
+		})
+	})
+	t.Run("good", func(t *testing.T) {
+		// 0x0100 hashes to 213492c0c6fc5d61497cf17249dd31cd9964b8a3
+		require.Equal(t, "213492c0c6fc5d61497cf17249dd31cd9964b8a3", hex.EncodeToString(c.ripemd160(ic, []stackitem.Item{stackitem.NewByteArray([]byte{1, 0})}).Value().([]byte)))
+	})
+}

pkg/core/native/designate.go

@@ -52,7 +52,7 @@ type roleData struct {
 }
 
 const (
-	designateContractID = -6
+	designateContractID = -8
 
 	// maxNodeCount is the maximum number of nodes to set the role for.
 	maxNodeCount = 32

pkg/core/native/ledger.go

@@ -26,7 +26,7 @@ type Ledger struct {
 }
 
 const (
-	ledgerContractID = -2
+	ledgerContractID = -4
 
 	prefixBlockHash    = 9
 	prefixCurrentBlock = 12

pkg/core/native/name_service.go

@@ -54,7 +54,7 @@ const (
 )
 
 const (
-	nameServiceID = -8
+	nameServiceID = -10
 
 	prefixRoots       = 10
 	prefixDomainPrice = 22

pkg/core/native/native_gas.go

@@ -18,7 +18,7 @@ type GAS struct {
 	NEO *NEO
 }
 
-const gasContractID = -4
+const gasContractID = -6
 
 // GASFactor is a divisor for finding GAS integral value.
 const GASFactor = NEOTotalSupply

pkg/core/native/native_neo.go

@@ -50,7 +50,7 @@ type NEO struct {
 }
 
 const (
-	neoContractID = -3
+	neoContractID = -5
 	// NEOTotalSupply is the total amount of NEO in the system.
 	NEOTotalSupply = 100000000
 	// prefixCandidate is a prefix used to store validator's data.

pkg/core/native/nativenames/names.go

@@ -11,4 +11,5 @@ const (
 	Designation = "RoleManagement"
 	Notary      = "Notary"
 	NameService = "NameService"
+	CryptoLib   = "CryptoLib"
 )

pkg/core/native/oracle.go

@@ -47,7 +47,7 @@ type Oracle struct {
 }
 
 const (
-	oracleContractID  = -7
+	oracleContractID  = -9
 	maxURLLength      = 256
 	maxFilterLength   = 128
 	maxCallbackLength = 32

pkg/core/native/policy.go

@@ -19,7 +19,7 @@ import (
 )
 
 const (
-	policyContractID = -5
+	policyContractID = -7
 
 	defaultExecFeeFactor      = interop.DefaultBaseExecFee
 	defaultFeePerByte         = 1000