[crypto]: add bls (#675)

* [crypto]: add bls

* [wip: crypto] integrate bls into morpheusvm

* [wip: crypto] add integration test

* [crypto]: support bls + integration test

* [crypto] create wrapper for bls

* [crypto] remove comment

* [crypto] fix BLS unit tests

* [crypto] fix lint

* [crypto] fix lint

* [crypto] fix lint

* [crypto] cleanup

* [crypto] remove blst usage

* [crypto] documentation explaining mul 2

* [crypto] use avalanchego import for Warp in integration test

* [crypto] use switch for checkKeyType

* [crypto] refactor unmarshalBLS

* [crypto] use pointers in BLS struct field

* [crypto] remove deserialize/serialize use from/to

* [crypto] fix return err

* [crypto] address minor changes

Author: wlawt

crypto/bls/private.go

@@ -0,0 +1,40 @@
+// Copyright (C) 2023, Ava Labs, Inc. All rights reserved.
+// See the file LICENSE for licensing terms.
+
+package bls
+
+import (
+	"errors"
+
+	"github.com/ava-labs/avalanchego/utils/crypto/bls"
+)
+
+const PrivateKeyLen = bls.SecretKeyLen
+
+var errFailedPrivateKeyDeserialize = errors.New("couldn't deserialize secret key")
+
+type PrivateKey = bls.SecretKey
+
+func GeneratePrivateKey() (*PrivateKey, error) {
+	return bls.NewSecretKey()
+}
+
+func PrivateKeyToBytes(pk *PrivateKey) []byte {
+	return bls.SecretKeyToBytes(pk)
+}
+
+func PrivateKeyFromBytes(pkBytes []byte) (*PrivateKey, error) {
+	pk, err := bls.SecretKeyFromBytes(pkBytes)
+	if err != nil {
+		return nil, errFailedPrivateKeyDeserialize
+	}
+	return pk, nil
+}
+
+func PublicFromPrivateKey(pk *PrivateKey) *PublicKey {
+	return bls.PublicFromSecretKey(pk)
+}
+
+func Sign(msg []byte, pk *PrivateKey) *Signature {
+	return bls.Sign(pk, msg)
+}

crypto/bls/private_test.go

@@ -0,0 +1,49 @@
+// Copyright (C) 2023, Ava Labs, Inc. All rights reserved.
+// See the file LICENSE for licensing terms.
+
+package bls
+
+import (
+	"testing"
+
+	"github.com/stretchr/testify/require"
+
+	"github.com/ava-labs/avalanchego/utils"
+)
+
+func TestPrivateKeyFromBytesZero(t *testing.T) {
+	require := require.New(t)
+
+	var skArr [PrivateKeyLen]byte
+	skBytes := skArr[:]
+	_, err := PrivateKeyFromBytes(skBytes)
+	require.ErrorIs(err, errFailedPrivateKeyDeserialize)
+}
+
+func TestPrivateKeyFromBytesWrongSize(t *testing.T) {
+	require := require.New(t)
+
+	skBytes := utils.RandomBytes(PrivateKeyLen + 1)
+	_, err := PrivateKeyFromBytes(skBytes)
+	require.ErrorIs(err, errFailedPrivateKeyDeserialize)
+}
+
+func TestPrivateKeyBytes(t *testing.T) {
+	require := require.New(t)
+
+	msg := utils.RandomBytes(1234)
+
+	sk, err := GeneratePrivateKey()
+	require.NoError(err)
+	sig := Sign(msg, sk)
+	skBytes := PrivateKeyToBytes(sk)
+
+	sk2, err := PrivateKeyFromBytes(skBytes)
+	require.NoError(err)
+	sig2 := Sign(msg, sk2)
+	sk2Bytes := PrivateKeyToBytes(sk2)
+
+	require.Equal(sk, sk2)
+	require.Equal(skBytes, sk2Bytes)
+	require.Equal(sig, sig2)
+}

crypto/bls/public.go

@@ -0,0 +1,34 @@
+// Copyright (C) 2023, Ava Labs, Inc. All rights reserved.
+// See the file LICENSE for licensing terms.
+
+package bls
+
+import (
+	"errors"
+
+	"github.com/ava-labs/avalanchego/utils/crypto/bls"
+)
+
+const PublicKeyLen = bls.PublicKeyLen
+
+var (
+	ErrNoPublicKeys              = errors.New("no public keys")
+	ErrFailedPublicKeyDecompress = errors.New("couldn't decompress public key")
+)
+
+type (
+	PublicKey          = bls.PublicKey
+	AggregatePublicKey = bls.AggregatePublicKey
+)
+
+func PublicKeyToBytes(pk *PublicKey) []byte {
+	return bls.PublicKeyToBytes(pk)
+}
+
+func PublicKeyFromBytes(pkBytes []byte) (*PublicKey, error) {
+	return bls.PublicKeyFromBytes(pkBytes)
+}
+
+func Verify(msg []byte, pk *PublicKey, sig *Signature) bool {
+	return bls.Verify(pk, sig, msg)
+}

crypto/bls/public_test.go

@@ -0,0 +1,38 @@
+// Copyright (C) 2023, Ava Labs, Inc. All rights reserved.
+// See the file LICENSE for licensing terms.
+
+package bls
+
+import (
+	"testing"
+
+	"github.com/stretchr/testify/require"
+
+	"github.com/ava-labs/avalanchego/utils"
+	"github.com/ava-labs/avalanchego/utils/crypto/bls"
+)
+
+func TestPublicKeyFromBytesWrongSize(t *testing.T) {
+	require := require.New(t)
+
+	pkBytes := utils.RandomBytes(PublicKeyLen + 1)
+	_, err := PublicKeyFromBytes(pkBytes)
+	require.ErrorIs(err, bls.ErrFailedPublicKeyDecompress)
+}
+
+func TestPublicKeyBytes(t *testing.T) {
+	require := require.New(t)
+
+	sk, err := GeneratePrivateKey()
+	require.NoError(err)
+
+	pk := PublicFromPrivateKey(sk)
+	pkBytes := PublicKeyToBytes(pk)
+
+	pk2, err := PublicKeyFromBytes(pkBytes)
+	require.NoError(err)
+	pk2Bytes := PublicKeyToBytes(pk2)
+
+	require.Equal(pk, pk2)
+	require.Equal(pkBytes, pk2Bytes)
+}

crypto/bls/signature.go

@@ -0,0 +1,27 @@
+// Copyright (C) 2023, Ava Labs, Inc. All rights reserved.
+// See the file LICENSE for licensing terms.
+
+package bls
+
+import (
+	"github.com/ava-labs/avalanchego/utils/crypto/bls"
+)
+
+const SignatureLen = bls.SignatureLen
+
+type (
+	Signature          = bls.Signature
+	AggregateSignature = bls.AggregateSignature
+)
+
+func SignatureToBytes(sig *Signature) []byte {
+	return bls.SignatureToBytes(sig)
+}
+
+func SignatureFromBytes(sigBytes []byte) (*Signature, error) {
+	return bls.SignatureFromBytes(sigBytes)
+}
+
+func AggregateSignatures(sigs []*Signature) (*Signature, error) {
+	return bls.AggregateSignatures(sigs)
+}

crypto/bls/signature_test.go

@@ -0,0 +1,51 @@
+// Copyright (C) 2023, Ava Labs, Inc. All rights reserved.
+// See the file LICENSE for licensing terms.
+
+package bls
+
+import (
+	"testing"
+
+	"github.com/stretchr/testify/require"
+
+	"github.com/ava-labs/avalanchego/utils"
+)
+
+func TestSignatureBytes(t *testing.T) {
+	require := require.New(t)
+
+	msg := utils.RandomBytes(1234)
+
+	sk, err := GeneratePrivateKey()
+	require.NoError(err)
+	sig := Sign(msg, sk)
+	sigBytes := SignatureToBytes(sig)
+
+	sig2, err := SignatureFromBytes(sigBytes)
+	require.NoError(err)
+	sig2Bytes := SignatureToBytes(sig2)
+
+	require.Equal(sig, sig2)
+	require.Equal(sigBytes, sig2Bytes)
+}
+
+func TestAggregateSignaturesNoop(t *testing.T) {
+	require := require.New(t)
+
+	msg := utils.RandomBytes(1234)
+
+	sk, err := GeneratePrivateKey()
+	require.NoError(err)
+
+	sig := Sign(msg, sk)
+	sigBytes := SignatureToBytes(sig)
+
+	aggSig, err := AggregateSignatures([]*Signature{sig})
+	require.NoError(err)
+
+	aggSigBytes := SignatureToBytes(aggSig)
+	require.NoError(err)
+
+	require.Equal(sig, aggSig)
+	require.Equal(sigBytes, aggSigBytes)
+}