diff --git a/lib/crypto/ed25519/ed25519.go b/lib/crypto/ed25519/ed25519.go index b91e5e9af8..28ab6c34d2 100644 --- a/lib/crypto/ed25519/ed25519.go +++ b/lib/crypto/ed25519/ed25519.go @@ -44,6 +44,24 @@ type PublicKey ed25519.PublicKey // PublicKeyBytes is an encoded ed25519 public key type PublicKeyBytes [PublicKeyLength]byte +// VerifySignature verifies a signature given a public key and a message +func VerifySignature(publicKey, signature, message []byte) error { + pubKey, err := NewPublicKey(publicKey) + if err != nil { + return fmt.Errorf("ed25519: %w", err) + } + + ok, err := pubKey.Verify(message, signature) + if err != nil { + return fmt.Errorf("ed25519: %w", err) + } else if !ok { + return fmt.Errorf("ed25519: %w: for message 0x%x, signature 0x%x and public key 0x%x", + crypto.ErrSignatureVerificationFailed, message, signature, publicKey) + } + + return nil +} + // String returns the PublicKeyBytes formatted as a hex string func (b PublicKeyBytes) String() string { pk := [PublicKeyLength]byte(b) diff --git a/lib/crypto/ed25519/ed25519_test.go b/lib/crypto/ed25519/ed25519_test.go index f83a3a8554..765c493741 100644 --- a/lib/crypto/ed25519/ed25519_test.go +++ b/lib/crypto/ed25519/ed25519_test.go @@ -4,11 +4,13 @@ package ed25519 import ( - ed25519 "crypto/ed25519" + "crypto/ed25519" + "fmt" "reflect" "testing" "github.com/ChainSafe/gossamer/lib/common" + "github.com/ChainSafe/gossamer/lib/crypto" bip39 "github.com/cosmos/go-bip39" "github.com/stretchr/testify/require" @@ -99,3 +101,62 @@ func TestNewKeypairFromMnenomic_Again(t *testing.T) { expectedPubkey := common.MustHexToBytes("0xf56d9231e7b7badd3f1e10ad15ef8aa08b70839723d0a2d10d7329f0ea2b8c61") require.Equal(t, expectedPubkey, kp.Public().Encode()) } + +func TestVerifySignature(t *testing.T) { + t.Parallel() + keypair, err := GenerateKeypair() + require.NoError(t, err) + + publicKey := keypair.public.Encode() + + message := []byte("Hello world!") + + signature, err := keypair.Sign(message) + require.NoError(t, err) + + testCase := map[string]struct { + publicKey, signature, message []byte + err error + }{ + "success": { + publicKey: publicKey, + signature: signature, + message: message, + }, + "bad public key input": { + publicKey: []byte{}, + signature: signature, + message: message, + err: fmt.Errorf("ed25519: cannot create public key: input is not 32 bytes"), + }, + "invalid signature length": { + publicKey: publicKey, + signature: []byte{}, + message: message, + err: fmt.Errorf("ed25519: invalid signature length"), + }, + "verification failed": { + publicKey: publicKey, + signature: signature, + message: []byte("a225e8c75da7da319af6335e7642d473"), + err: fmt.Errorf("ed25519: %w: for message 0x%x, signature 0x%x and public key 0x%x", + crypto.ErrSignatureVerificationFailed, []byte("a225e8c75da7da319af6335e7642d473"), signature, publicKey), + }, + } + + for name, value := range testCase { + testCase := value + t.Run(name, func(t *testing.T) { + t.Parallel() + + err := VerifySignature(testCase.publicKey, testCase.signature, testCase.message) + + if testCase.err != nil { + require.EqualError(t, err, testCase.err.Error()) + return + } + require.NoError(t, err) + }) + } + +} diff --git a/lib/crypto/secp256k1/secp256k1.go b/lib/crypto/secp256k1/secp256k1.go index 29dccfeb2c..dc4790ae8c 100644 --- a/lib/crypto/secp256k1/secp256k1.go +++ b/lib/crypto/secp256k1/secp256k1.go @@ -7,6 +7,7 @@ import ( "crypto/ecdsa" "encoding/hex" "errors" + "fmt" "github.com/ChainSafe/gossamer/lib/common" "github.com/ChainSafe/gossamer/lib/crypto" @@ -36,6 +37,17 @@ type PublicKey struct { key ecdsa.PublicKey } +// VerifySignature verifies a signature given a public key and a message +func VerifySignature(publicKey, signature, message []byte) error { + ok := secp256k1.VerifySignature(publicKey, message, signature) + if ok { + return nil + } + + return fmt.Errorf("secp256k1: %w: for message 0x%x, signature 0x%x and public key 0x%x", + crypto.ErrSignatureVerificationFailed, message, signature, publicKey) +} + // RecoverPublicKey returns the 64-byte uncompressed public key that created the given signature. func RecoverPublicKey(msg, sig []byte) ([]byte, error) { // update recovery bit diff --git a/lib/crypto/secp256k1/secp256k1_test.go b/lib/crypto/secp256k1/secp256k1_test.go index 7ae002066d..a0aaecacc5 100644 --- a/lib/crypto/secp256k1/secp256k1_test.go +++ b/lib/crypto/secp256k1/secp256k1_test.go @@ -4,10 +4,12 @@ package secp256k1 import ( + "fmt" "reflect" "testing" "github.com/ChainSafe/gossamer/lib/common" + "github.com/ChainSafe/gossamer/lib/crypto" "github.com/stretchr/testify/require" ) @@ -154,3 +156,48 @@ func TestRecoverPublicKeyCompressed(t *testing.T) { require.NoError(t, err) require.Equal(t, kp.Public(), r) } + +func TestVerifySignature(t *testing.T) { + t.Parallel() + keypair, err := GenerateKeypair() + require.NoError(t, err) + + message := []byte("a225e8c75da7da319af6335e7642d473") + + signature, err := keypair.Sign(message) + require.NoError(t, err) + + testCase := map[string]struct { + publicKey, signature, message []byte + err error + }{ + "success": { + publicKey: keypair.public.Encode(), + signature: signature[:64], + message: message, + }, + "verification failed": { + publicKey: keypair.public.Encode(), + signature: []byte{}, + message: message, + err: fmt.Errorf("secp256k1: %w: for message 0x%x, signature 0x and public key 0x%x", + crypto.ErrSignatureVerificationFailed, message, keypair.public.Encode()), + }, + } + + for name, value := range testCase { + testCase := value + t.Run(name, func(t *testing.T) { + t.Parallel() + + err := VerifySignature(testCase.publicKey, testCase.signature, testCase.message) + + if testCase.err != nil { + require.EqualError(t, err, testCase.err.Error()) + return + } + require.NoError(t, err) + }) + } + +} diff --git a/lib/runtime/sig_verifier.go b/lib/crypto/sig_verifier.go similarity index 64% rename from lib/runtime/sig_verifier.go rename to lib/crypto/sig_verifier.go index 5e1e8c59ad..80b5ca8be4 100644 --- a/lib/runtime/sig_verifier.go +++ b/lib/crypto/sig_verifier.go @@ -1,31 +1,32 @@ // Copyright 2021 ChainSafe Systems (ON) // SPDX-License-Identifier: LGPL-3.0-only -package runtime +package crypto import ( - "fmt" + "errors" "sync" "time" "github.com/ChainSafe/gossamer/internal/log" - "github.com/ChainSafe/gossamer/lib/crypto" - "github.com/ChainSafe/gossamer/lib/crypto/ed25519" - "github.com/ChainSafe/gossamer/lib/crypto/sr25519" - "github.com/ethereum/go-ethereum/crypto/secp256k1" ) -// Signature ... -type Signature struct { - PubKey []byte - Sign []byte - Msg []byte - KeyTypeID crypto.KeyType +var ErrSignatureVerificationFailed = errors.New("failed to verify signature") + +// SigVerifyFunc verifies a signature given a public key and a message +type SigVerifyFunc func(pubkey, sig, msg []byte) (err error) + +// SignatureInfo ... +type SignatureInfo struct { + PubKey []byte + Sign []byte + Msg []byte + VerifyFunc SigVerifyFunc } // SignatureVerifier ... type SignatureVerifier struct { - batch []*Signature + batch []*SignatureInfo init bool // Indicates whether the batch processing is started. invalid bool // Set to true if any signature verification fails. logger log.LeveledLogger @@ -41,7 +42,7 @@ type SignatureVerifier struct { // Signatures can be added to the batch using Add(). func NewSignatureVerifier(logger log.LeveledLogger) *SignatureVerifier { return &SignatureVerifier{ - batch: make([]*Signature, 0), + batch: make([]*SignatureInfo, 0), init: false, invalid: false, logger: logger, @@ -66,11 +67,11 @@ func (sv *SignatureVerifier) Start() { case <-sv.closeCh: return default: - sign := sv.Remove() - if sign == nil { + signature := sv.Remove() + if signature == nil { continue } - err := sign.verify() + err := signature.VerifyFunc(signature.PubKey, signature.Sign, signature.Msg) if err != nil { sv.logger.Errorf("[ext_crypto_start_batch_verify_version_1]: %s", err) sv.Invalid() @@ -103,7 +104,7 @@ func (sv *SignatureVerifier) Invalid() { } // Add ... -func (sv *SignatureVerifier) Add(s *Signature) { +func (sv *SignatureVerifier) Add(s *SignatureInfo) { if sv.IsInvalid() { return } @@ -114,7 +115,7 @@ func (sv *SignatureVerifier) Add(s *Signature) { } // Remove returns the first signature from the batch. Returns nil if batch is empty. -func (sv *SignatureVerifier) Remove() *Signature { +func (sv *SignatureVerifier) Remove() *SignatureInfo { sv.Lock() defer sv.Unlock() if len(sv.batch) == 0 { @@ -130,7 +131,7 @@ func (sv *SignatureVerifier) Reset() { sv.Lock() defer sv.Unlock() sv.init = false - sv.batch = make([]*Signature, 0) + sv.batch = make([]*SignatureInfo, 0) sv.invalid = false sv.closeCh = make(chan struct{}) } @@ -153,32 +154,3 @@ func (sv *SignatureVerifier) Finish() bool { sv.Reset() return !isInvalid } - -func (sig *Signature) verify() error { - switch sig.KeyTypeID { - case crypto.Ed25519Type: - pubKey, err := ed25519.NewPublicKey(sig.PubKey) - if err != nil { - return fmt.Errorf("failed to fetch ed25519 public key: %s", err) - } - ok, err := pubKey.Verify(sig.Msg, sig.Sign) - if err != nil || !ok { - return fmt.Errorf("failed to verify ed25519 signature: %s", err) - } - case crypto.Sr25519Type: - pubKey, err := sr25519.NewPublicKey(sig.PubKey) - if err != nil { - return fmt.Errorf("failed to fetch sr25519 public key: %s", err) - } - ok, err := pubKey.Verify(sig.Msg, sig.Sign) - if err != nil || !ok { - return fmt.Errorf("failed to verify sr25519 signature: %s", err) - } - case crypto.Secp256k1Type: - ok := secp256k1.VerifySignature(sig.PubKey, sig.Msg, sig.Sign) - if !ok { - return fmt.Errorf("failed to verify secp256k1 signature") - } - } - return nil -} diff --git a/lib/crypto/sig_verifier_test.go b/lib/crypto/sig_verifier_test.go new file mode 100644 index 0000000000..fcaec07b88 --- /dev/null +++ b/lib/crypto/sig_verifier_test.go @@ -0,0 +1,126 @@ +// Copyright 2021 ChainSafe Systems (ON) +// SPDX-License-Identifier: LGPL-3.0-only + +package crypto_test + +import ( + "io" + "testing" + + "github.com/ChainSafe/gossamer/internal/log" + "github.com/ChainSafe/gossamer/lib/crypto" + "github.com/ChainSafe/gossamer/lib/crypto/ed25519" + "github.com/ChainSafe/gossamer/lib/crypto/secp256k1" + "github.com/ChainSafe/gossamer/lib/crypto/sr25519" + + "github.com/stretchr/testify/require" +) + +func TestVerifySignature(t *testing.T) { + t.Parallel() + + message := []byte("a225e8c75da7da319af6335e7642d473") + + edKeypair, err := ed25519.GenerateKeypair() + require.NoError(t, err) + edSign, err := edKeypair.Sign(message) + require.NoError(t, err) + + secpKeypair, err := secp256k1.GenerateKeypair() + require.NoError(t, err) + secpSign, err := secpKeypair.Sign(message) + require.NoError(t, err) + + srKeypair, err := sr25519.GenerateKeypair() + require.NoError(t, err) + srSign, err := srKeypair.Sign(message) + require.NoError(t, err) + + testCase := map[string]struct { + expect bool + signaturesToVerify []*crypto.SignatureInfo + }{ + "success": { + expect: true, + signaturesToVerify: []*crypto.SignatureInfo{ + 0: { + PubKey: edKeypair.Public().Encode(), + Sign: edSign, + Msg: message, + VerifyFunc: ed25519.VerifySignature, + }, + 1: { + PubKey: secpKeypair.Public().Encode(), + Sign: secpSign[:64], + Msg: message, + VerifyFunc: secp256k1.VerifySignature, + }, + 2: { + PubKey: srKeypair.Public().Encode(), + Sign: srSign, + Msg: message, + VerifyFunc: sr25519.VerifySignature, + }, + }, + }, + "bad public key input": { + expect: false, + signaturesToVerify: []*crypto.SignatureInfo{ + 0: { + PubKey: []byte{}, + Sign: edSign, + Msg: message, + VerifyFunc: ed25519.VerifySignature, + }, + 1: { + PubKey: []byte{}, + Sign: srSign, + Msg: message, + VerifyFunc: sr25519.VerifySignature, + }, + }, + }, + "verification failed": { + expect: false, + signaturesToVerify: []*crypto.SignatureInfo{ + 0: { + PubKey: edKeypair.Public().Encode(), + Sign: []byte{}, + Msg: message, + VerifyFunc: ed25519.VerifySignature, + }, + 1: { + PubKey: srKeypair.Public().Encode(), + Sign: []byte{}, + Msg: message, + VerifyFunc: sr25519.VerifySignature, + }, + 2: { + PubKey: secpKeypair.Public().Encode(), + Sign: []byte{}, + Msg: message, + VerifyFunc: secp256k1.VerifySignature, + }, + }, + }, + } + + for name, value := range testCase { + testCase := value + t.Run(name, func(t *testing.T) { + t.Parallel() + + signVerify := crypto.NewSignatureVerifier(log.New(log.SetWriter(io.Discard))) + + for _, sig := range testCase.signaturesToVerify { + signVerify.Add(sig) + } + + signVerify.Start() + + ok := signVerify.Finish() + require.Equal(t, testCase.expect, ok) + }) + } + +} diff --git a/lib/crypto/sr25519/sr25519.go b/lib/crypto/sr25519/sr25519.go index 339da172a1..799f720d54 100644 --- a/lib/crypto/sr25519/sr25519.go +++ b/lib/crypto/sr25519/sr25519.go @@ -6,6 +6,7 @@ package sr25519 import ( "encoding/hex" "errors" + "fmt" "github.com/ChainSafe/gossamer/lib/common" "github.com/ChainSafe/gossamer/lib/crypto" @@ -48,6 +49,24 @@ type PrivateKey struct { key *sr25519.SecretKey } +// VerifySignature verifies a signature given a public key and a message +func VerifySignature(publicKey, signature, message []byte) error { + pubKey, err := NewPublicKey(publicKey) + if err != nil { + return fmt.Errorf("sr25519: %w", err) + } + + ok, err := pubKey.Verify(message, signature) + if err != nil { + return fmt.Errorf("sr25519: %w", err) + } else if !ok { + return fmt.Errorf("sr25519: %w: for message 0x%x, signature 0x%x and public key 0x%x", + crypto.ErrSignatureVerificationFailed, message, signature, publicKey) + } + + return nil +} + // NewKeypair returns a sr25519 Keypair given a schnorrkel secret key func NewKeypair(priv *sr25519.SecretKey) (*Keypair, error) { pub, err := priv.Public() diff --git a/lib/crypto/sr25519/sr25519_test.go b/lib/crypto/sr25519/sr25519_test.go index a6440c738e..53fbfe7e52 100644 --- a/lib/crypto/sr25519/sr25519_test.go +++ b/lib/crypto/sr25519/sr25519_test.go @@ -5,8 +5,11 @@ package sr25519 import ( "crypto/rand" + "errors" + "fmt" "testing" + "github.com/ChainSafe/gossamer/lib/crypto" bip39 "github.com/cosmos/go-bip39" "github.com/gtank/merlin" "github.com/stretchr/testify/require" @@ -119,3 +122,63 @@ func TestNewKeypairFromMnenomic(t *testing.T) { _, err = NewKeypairFromMnenomic(mnemonic, "") require.NoError(t, err) } + +func TestVerifySignature(t *testing.T) { + t.Parallel() + + keypair, err := GenerateKeypair() + require.NoError(t, err) + + publicKey := keypair.public.Encode() + + message := []byte("Hello world!") + + signature, err := keypair.Sign(message) + require.NoError(t, err) + + testCase := map[string]struct { + publicKey, signature, message []byte + err error + }{ + "success": { + publicKey: publicKey, + signature: signature, + message: message, + }, + "bad public key input": { + publicKey: []byte{}, + signature: signature, + message: message, + err: errors.New("sr25519: cannot create public key: input is not 32 bytes"), + }, + "invalid signature length": { + publicKey: publicKey, + signature: []byte{}, + message: message, + err: fmt.Errorf("sr25519: invalid signature length"), + }, + "verification failed": { + publicKey: publicKey, + signature: signature, + message: []byte("a225e8c75da7da319af6335e7642d473"), + err: fmt.Errorf("sr25519: %w: for message 0x%x, signature 0x%x and public key 0x%x", + crypto.ErrSignatureVerificationFailed, []byte("a225e8c75da7da319af6335e7642d473"), signature, publicKey), + }, + } + + for name, value := range testCase { + testCase := value + t.Run(name, func(t *testing.T) { + t.Parallel() + + err := VerifySignature(testCase.publicKey, testCase.signature, testCase.message) + + if testCase.err != nil { + require.EqualError(t, err, testCase.err.Error()) + return + } + require.NoError(t, err) + }) + } + +} diff --git a/lib/runtime/life/instance.go b/lib/runtime/life/instance.go index ec22bf7eb3..f5d50f2732 100644 --- a/lib/runtime/life/instance.go +++ b/lib/runtime/life/instance.go @@ -12,6 +12,7 @@ import ( "github.com/ChainSafe/gossamer/internal/log" "github.com/ChainSafe/gossamer/lib/common" + "github.com/ChainSafe/gossamer/lib/crypto" "github.com/ChainSafe/gossamer/lib/keystore" "github.com/ChainSafe/gossamer/lib/runtime" @@ -112,7 +113,7 @@ func NewInstance(code []byte, cfg *Config) (*Instance, error) { NodeStorage: cfg.NodeStorage, Network: cfg.Network, Transaction: cfg.Transaction, - SigVerifier: runtime.NewSignatureVerifier(logger), + SigVerifier: crypto.NewSignatureVerifier(logger), } logger.Debugf("creating new runtime instance with context: %v", runtimeCtx) diff --git a/lib/runtime/life/resolver.go b/lib/runtime/life/resolver.go index 3ce00cb6d7..7f19ea5869 100644 --- a/lib/runtime/life/resolver.go +++ b/lib/runtime/life/resolver.go @@ -935,11 +935,11 @@ func ext_crypto_ed25519_verify_version_1(vm *exec.VirtualMachine) int64 { } if sigVerifier.IsStarted() { - signature := runtime.Signature{ - PubKey: pubKey.Encode(), - Sign: signature, - Msg: message, - KeyTypeID: crypto.Ed25519Type, + signature := crypto.SignatureInfo{ + PubKey: pubKey.Encode(), + Sign: signature, + Msg: message, + VerifyFunc: ed25519.VerifySignature, } sigVerifier.Add(&signature) return 1 @@ -1124,11 +1124,11 @@ func ext_crypto_sr25519_verify_version_1(vm *exec.VirtualMachine) int64 { pub.Hex(), message, signature) if sigVerifier.IsStarted() { - signature := runtime.Signature{ - PubKey: pub.Encode(), - Sign: signature, - Msg: message, - KeyTypeID: crypto.Sr25519Type, + signature := crypto.SignatureInfo{ + PubKey: pub.Encode(), + Sign: signature, + Msg: message, + VerifyFunc: sr25519.VerifySignature, } sigVerifier.Add(&signature) return 1 diff --git a/lib/runtime/test_helpers.go b/lib/runtime/test_helpers.go index 4da3c3b963..e9e7d0f5f9 100644 --- a/lib/runtime/test_helpers.go +++ b/lib/runtime/test_helpers.go @@ -115,9 +115,9 @@ func (*TestRuntimeNetwork) NetworkState() common.NetworkState { } } -func generateEd25519Signatures(t *testing.T, n int) []*Signature { +func generateEd25519Signatures(t *testing.T, n int) []*crypto.SignatureInfo { t.Helper() - signs := make([]*Signature, n) + signs := make([]*crypto.SignatureInfo, n) for i := 0; i < n; i++ { msg := []byte("Hello") key, err := ed25519.GenerateKeypair() @@ -126,11 +126,11 @@ func generateEd25519Signatures(t *testing.T, n int) []*Signature { sign, err := key.Private().Sign(msg) require.NoError(t, err) - signs[i] = &Signature{ - PubKey: key.Public().Encode(), - Sign: sign, - Msg: msg, - KeyTypeID: crypto.Ed25519Type, + signs[i] = &crypto.SignatureInfo{ + PubKey: key.Public().Encode(), + Sign: sign, + Msg: msg, + VerifyFunc: ed25519.VerifySignature, } } return signs diff --git a/lib/runtime/types.go b/lib/runtime/types.go index b246920ddb..312be14058 100644 --- a/lib/runtime/types.go +++ b/lib/runtime/types.go @@ -6,6 +6,7 @@ package runtime import ( "github.com/ChainSafe/gossamer/internal/log" "github.com/ChainSafe/gossamer/lib/common" + "github.com/ChainSafe/gossamer/lib/crypto" "github.com/ChainSafe/gossamer/lib/keystore" "github.com/ChainSafe/gossamer/lib/runtime/offchain" ) @@ -67,7 +68,7 @@ type Context struct { NodeStorage NodeStorage Network BasicNetwork Transaction TransactionState - SigVerifier *SignatureVerifier + SigVerifier *crypto.SignatureVerifier OffchainHTTPSet *offchain.HTTPSet } diff --git a/lib/runtime/types_test.go b/lib/runtime/types_test.go index af5c2bf569..98627f241d 100644 --- a/lib/runtime/types_test.go +++ b/lib/runtime/types_test.go @@ -19,7 +19,7 @@ import ( func TestBackgroundSignVerification(t *testing.T) { signs := generateEd25519Signatures(t, 2) - signVerify := NewSignatureVerifier(log.New(log.SetWriter(io.Discard))) + signVerify := crypto.NewSignatureVerifier(log.New(log.SetWriter(io.Discard))) signVerify.Start() @@ -34,7 +34,7 @@ func TestBackgroundSignVerification(t *testing.T) { func TestBackgroundSignVerificationMultipleStart(t *testing.T) { signs := generateEd25519Signatures(t, 2) - signVerify := NewSignatureVerifier(log.New(log.SetWriter(io.Discard))) + signVerify := crypto.NewSignatureVerifier(log.New(log.SetWriter(io.Discard))) for ii := 0; ii < 5; ii++ { require.False(t, signVerify.IsStarted()) @@ -60,16 +60,16 @@ func TestInvalidSignatureBatch(t *testing.T) { sigData, err := common.HexToBytes("0x90f27b8b488db00b00606796d2987f6a5f59ae62ea05effe84fef5b8b0e549984a691139ad57a3f0b906637673aa2f63d1f55cb1a69199d4009eea23ceaddc9301") //nolint:lll require.Nil(t, err) - signature := &Signature{ - PubKey: key.Public().Encode(), - Sign: sigData, - Msg: msg, - KeyTypeID: crypto.Ed25519Type, + signature := &crypto.SignatureInfo{ + PubKey: key.Public().Encode(), + Sign: sigData, + Msg: msg, + VerifyFunc: ed25519.VerifySignature, } signs = append(signs, signature) - signVerify := NewSignatureVerifier(log.New(log.SetWriter(io.Discard))) + signVerify := crypto.NewSignatureVerifier(log.New(log.SetWriter(io.Discard))) signVerify.Start() for _, sig := range signs { @@ -80,7 +80,7 @@ func TestInvalidSignatureBatch(t *testing.T) { func TestValidSignatureBatch(t *testing.T) { signs := generateEd25519Signatures(t, 2) - signVerify := NewSignatureVerifier(log.New(log.SetWriter(io.Discard))) + signVerify := crypto.NewSignatureVerifier(log.New(log.SetWriter(io.Discard))) signVerify.Start() @@ -101,11 +101,11 @@ func TestAllCryptoTypeSignature(t *testing.T) { srSig, err := srKey.Private().Sign(srMsg) require.NoError(t, err) - srSignature := &Signature{ - PubKey: srKey.Public().Encode(), - Sign: srSig, - Msg: srMsg, - KeyTypeID: crypto.Sr25519Type, + srSignature := &crypto.SignatureInfo{ + PubKey: srKey.Public().Encode(), + Sign: srSig, + Msg: srMsg, + VerifyFunc: sr25519.VerifySignature, } blakeHash, err := common.Blake2bHash([]byte("secp256k1")) @@ -118,14 +118,14 @@ func TestAllCryptoTypeSignature(t *testing.T) { require.NoError(t, err) secpSigData = secpSigData[:len(secpSigData)-1] // remove recovery id - secpSignature := &Signature{ - PubKey: kp.Public().Encode(), - Sign: secpSigData, - Msg: blakeHash.ToBytes(), - KeyTypeID: crypto.Secp256k1Type, + secpSignature := &crypto.SignatureInfo{ + PubKey: kp.Public().Encode(), + Sign: secpSigData, + Msg: blakeHash.ToBytes(), + VerifyFunc: secp256k1.VerifySignature, } - signVerify := NewSignatureVerifier(log.New(log.SetWriter(io.Discard))) + signVerify := crypto.NewSignatureVerifier(log.New(log.SetWriter(io.Discard))) signVerify.Start() diff --git a/lib/runtime/wasmer/imports.go b/lib/runtime/wasmer/imports.go index 119a6f9585..1d9244e3fc 100644 --- a/lib/runtime/wasmer/imports.go +++ b/lib/runtime/wasmer/imports.go @@ -384,11 +384,11 @@ func ext_crypto_ed25519_verify_version_1(context unsafe.Pointer, sig C.int32_t, } if sigVerifier.IsStarted() { - signature := runtime.Signature{ - PubKey: pubKey.Encode(), - Sign: signature, - Msg: message, - KeyTypeID: crypto.Ed25519Type, + signature := crypto.SignatureInfo{ + PubKey: pubKey.Encode(), + Sign: signature, + Msg: message, + VerifyFunc: ed25519.VerifySignature, } sigVerifier.Add(&signature) return 1 @@ -475,11 +475,11 @@ func ext_crypto_ecdsa_verify_version_2(context unsafe.Pointer, sig C.int32_t, ms } if sigVerifier.IsStarted() { - signature := runtime.Signature{ - PubKey: pub.Encode(), - Sign: signature, - Msg: hash[:], - KeyTypeID: crypto.Secp256k1Type, + signature := crypto.SignatureInfo{ + PubKey: pub.Encode(), + Sign: signature, + Msg: hash[:], + VerifyFunc: secp256k1.VerifySignature, } sigVerifier.Add(&signature) return C.int32_t(1) @@ -701,11 +701,11 @@ func ext_crypto_sr25519_verify_version_1(context unsafe.Pointer, sig C.int32_t, pub.Hex(), message, signature) if sigVerifier.IsStarted() { - signature := runtime.Signature{ - PubKey: pub.Encode(), - Sign: signature, - Msg: message, - KeyTypeID: crypto.Sr25519Type, + signature := crypto.SignatureInfo{ + PubKey: pub.Encode(), + Sign: signature, + Msg: message, + VerifyFunc: sr25519.VerifySignature, } sigVerifier.Add(&signature) return 1 @@ -743,11 +743,11 @@ func ext_crypto_sr25519_verify_version_2(context unsafe.Pointer, sig C.int32_t, pub.Hex(), message, signature) if sigVerifier.IsStarted() { - signature := runtime.Signature{ - PubKey: pub.Encode(), - Sign: signature, - Msg: message, - KeyTypeID: crypto.Sr25519Type, + signature := crypto.SignatureInfo{ + PubKey: pub.Encode(), + Sign: signature, + Msg: message, + VerifyFunc: sr25519.VerifySignature, } sigVerifier.Add(&signature) return 1 diff --git a/lib/runtime/wasmer/instance.go b/lib/runtime/wasmer/instance.go index 303fc93901..7c87ceb287 100644 --- a/lib/runtime/wasmer/instance.go +++ b/lib/runtime/wasmer/instance.go @@ -15,6 +15,8 @@ import ( "github.com/ChainSafe/gossamer/lib/runtime/offchain" "github.com/ChainSafe/gossamer/lib/trie" + "github.com/ChainSafe/gossamer/lib/crypto" + wasm "github.com/wasmerio/go-ext-wasm/wasmer" ) @@ -137,7 +139,7 @@ func NewInstance(code []byte, cfg *Config) (*Instance, error) { NodeStorage: cfg.NodeStorage, Network: cfg.Network, Transaction: cfg.Transaction, - SigVerifier: runtime.NewSignatureVerifier(logger), + SigVerifier: crypto.NewSignatureVerifier(logger), OffchainHTTPSet: offchain.NewHTTPSet(), }