bls take crypto interface

plugin/consensus/para/parablssign.go

@@ -413,7 +413,12 @@ func (b *blsClient) aggregateSigns(signs [][]byte) (crypto.Signature, error) {
 		}
 		signatures = append(signatures, si)
 	}
-	return b.cryptoCli.Aggregate(signatures)
+	agg, err := crypto.ToAggregate(b.cryptoCli)
+	if err != nil {
+		return nil, types.ErrNotSupport
+	}
+
+	return agg.Aggregate(signatures)
 }
 
 func (b *blsClient) updatePeers(id string, add bool) {

plugin/consensus/para/parablssign_test.go

@@ -7,12 +7,12 @@ package para
 import (
 	"testing"
 
+	"github.com/33cn/chain33/common"
 	"github.com/33cn/chain33/types"
-	"github.com/33cn/plugin/plugin/dapp/evm/executor/vm/common"
 
+	"github.com/33cn/chain33/common/crypto"
 	pt "github.com/33cn/plugin/plugin/dapp/paracross/types"
-	"github.com/herumi/bls-eth-go-binary/bls"
-	"github.com/magiconair/properties/assert"
+	"github.com/stretchr/testify/assert"
 )
 
 func TestSetAddrsBitMap(t *testing.T) {
@@ -60,27 +60,29 @@ func TestIntegrateCommits(t *testing.T) {
 }
 
 func TestBlsSignMain(t *testing.T) {
-	//只初始化一次，多次初始化会并行产生冲突
-	bls.Init(bls.BLS12_381)
+	cryptoCli, err := crypto.New("bls")
+	assert.NoError(t, err)
 
-	testSecpPrikey2BlsPub(t)
-	testBlsSign(t)
-	testVerifyBlsSign(t)
+	testSecpPrikey2BlsPub(t, cryptoCli)
+	testBlsSign(t, cryptoCli)
+	testVerifyBlsSign(t, cryptoCli)
 }
 
-func testSecpPrikey2BlsPub(t *testing.T) {
+func testSecpPrikey2BlsPub(t *testing.T, cryptCli crypto.Crypto) {
+	cli := blsClient{}
+	cli.cryptoCli = cryptCli
 	key := ""
-	ret, _ := secp256Prikey2BlsPub(key)
+	ret, _ := cli.secp256Prikey2BlsPub(key)
 	assert.Equal(t, "", ret)
 
 	//real prikey="1626b254a75e5c44de9500a0c7897643e7736c09a7270b807546acb7cf7c94c9"
 	key = "0xcacb1f5d51700aea07fca2246ab43b0917d70405c65edea9b5063d72eb5c6b71"
 	q := "0x980287e26d4d44f8c57944ffc096f7d98a460c97dadbffaed14ff0de901fa7f8afc59fcb1805a0b031e5eae5601df1c2"
-	ret, _ = secp256Prikey2BlsPub(key)
+	ret, _ = cli.secp256Prikey2BlsPub(key)
 	assert.Equal(t, q, ret)
 }
 
-func testBlsSign(t *testing.T) {
+func testBlsSign(t *testing.T, cryptCli crypto.Crypto) {
 	status := &pt.ParacrossNodeStatus{}
 	status.Height = 0
 	status.Title = "user.p.para."
@@ -90,50 +92,60 @@ func testBlsSign(t *testing.T) {
 	PriKS := "6da92a632ab7deb67d38c0f6560bcfed28167998f6496db64c258d5e8393a81b"
 
 	commit := &pt.ParacrossCommitAction{Status: status}
-	client := &blsClient{}
-	client.peersBlsPubKey = make(map[string]*bls.PublicKey)
-
-	var prikey bls.SecretKey
-	prikey.DeserializeHexStr(PriKS)
-	t.Log("pri", prikey.SerializeToHexStr())
-	client.blsPriKey = &prikey
-	err := client.blsSign([]*pt.ParacrossCommitAction{commit})
-	assert.Equal(t, err, nil)
-
-	var pub bls.PublicKey
-	pub.DeserializeHexStr(PubKS)
-	client.peersBlsPubKey[KS] = &pub
-	t.Log("pubks", pub.SerializeToHexStr())
-	var sign bls.Sign
-	sign.Deserialize(commit.Bls.Sign)
+	client := &blsClient{cryptoCli: cryptCli}
+	client.peersBlsPubKey = make(map[string]crypto.PubKey)
+
+	p, err := common.FromHex(PriKS)
+	assert.NoError(t, err)
+	prikey, err := client.cryptoCli.PrivKeyFromBytes(p)
+	assert.NoError(t, err)
+
+	client.blsPriKey = prikey
+	err = client.blsSign([]*pt.ParacrossCommitAction{commit})
+	assert.NoError(t, err)
+
+	p, err = common.FromHex(PubKS)
+	assert.NoError(t, err)
+	pub, err := cryptCli.PubKeyFromBytes(p)
+	assert.NoError(t, err)
+	client.peersBlsPubKey[KS] = pub
+
+	sign, err := cryptCli.SignatureFromBytes(commit.Bls.Sign)
+	assert.NoError(t, err)
 	msg := types.Encode(status)
 
-	ret := sign.VerifyByte(&pub, msg)
+	ret := pub.VerifyBytes(msg, sign)
 	assert.Equal(t, ret, true)
 
 	err = client.verifyBlsSign(KS, commit)
 	assert.Equal(t, err, nil)
 }
 
-func testVerifyBlsSign(t *testing.T) {
-	client := &blsClient{}
-	client.peersBlsPubKey = make(map[string]*bls.PublicKey)
+func testVerifyBlsSign(t *testing.T, cryptCli crypto.Crypto) {
+	client := &blsClient{cryptoCli: cryptCli}
+	client.peersBlsPubKey = make(map[string]crypto.PubKey)
 	KS := "1KSBd17H7ZK8iT37aJztFB22XGwsPTdwE4"
 	PubKS := "a3d97d4186c80268fe6d3689dd574599e25df2dffdcff03f7d8ef64a3bd483241b7d0985958990de2d373d5604caf805"
-	var pub bls.PublicKey
-	pub.DeserializeHexStr(PubKS)
-	client.peersBlsPubKey[KS] = &pub
+
+	p, err := common.FromHex(PubKS)
+	assert.NoError(t, err)
+	pub, err := cryptCli.PubKeyFromBytes(p)
+	assert.NoError(t, err)
+	client.peersBlsPubKey[KS] = pub
 
 	commit := &pt.ParacrossCommitAction{}
 	blsInfo := &pt.ParacrossCommitBlsInfo{}
 	signData := "0x82753675393576758571cbbaefada498614b4a0a967ca2dd5724eb46ecfd1c89f1e49792ebbe1866c1d6d6ceaf3054c7189751477a5b7312218eb77dcab1bfb6287c6fbf2e1c6cf8fe2ade7c17596b081dc98be785a34db5b45a5cca08e7e744"
-	blsInfo.Sign = common.FromHex(signData)
+	blsInfo.Sign, err = common.FromHex(signData)
+	assert.NoError(t, err)
+
 	status := &pt.ParacrossNodeStatus{}
 	data := "0x1a0c757365722e702e706172612e322097162f9d4a888121fdba2fb1ab402596acdbcb602121bd12284adb739d85f225"
-	msg := common.FromHex(data)
+	msg, err := common.FromHex(data)
+	assert.NoError(t, err)
 	types.Decode(msg, status)
 	commit.Status = status
 	commit.Bls = blsInfo
-	err := client.verifyBlsSign(KS, commit)
+	err = client.verifyBlsSign(KS, commit)
 	assert.Equal(t, err, nil)
 }

plugin/dapp/paracross/cmd/build.sh

@@ -11,6 +11,7 @@ OUT_DIR="${1}/$strapp"
 #SRC_CLI=github.com/33cn/plugin/cli
 #go build -v -o "${PARACLI}" -ldflags "-X ${SRC_CLI}/buildflags.ParaName=user.p.${PARANAME}. -X ${SRC_CLI}/buildflags.RPCAddr=http://localhost:8901" "${SRC_CLI}"
 
+mkdir -p "${OUT_DIR}"
 # shellcheck disable=SC2086
 cp ./build/* "${OUT_DIR}"
 

plugin/dapp/paracross/executor/action.go

@@ -12,13 +12,13 @@ import (
 	"github.com/33cn/chain33/account"
 	"github.com/33cn/chain33/client"
 	"github.com/33cn/chain33/common"
+	"github.com/33cn/chain33/common/crypto"
 	dbm "github.com/33cn/chain33/common/db"
 	"github.com/33cn/chain33/system/dapp"
 	"github.com/33cn/chain33/types"
 	"github.com/33cn/chain33/util"
 	pt "github.com/33cn/plugin/plugin/dapp/paracross/types"
 	"github.com/golang/protobuf/proto"
-	"github.com/herumi/bls-eth-go-binary/bls"
 	"github.com/pkg/errors"
 )
 
@@ -413,8 +413,8 @@ func getValidAddrs(nodes map[string]struct{}, addrs []string) []string {
 }
 
 //bls签名共识交易验证 大约平均耗时30ms (20~40ms)
-func (a *action) verifyBlsSign(nodesArry []string, commit *pt.ParacrossCommitAction) ([]string, error) {
-	//1.　获取addr对应的bls 公钥 单独耗时3ms (3 addrs)
+func (a *action) procBlsSign(nodesArry []string, commit *pt.ParacrossCommitAction) ([]string, error) {
+
 	signAddrs := getAddrsByBitMap(nodesArry, commit.Bls.AddrsMap)
 	var pubs []string
 	for _, addr := range signAddrs {
@@ -424,7 +424,7 @@ func (a *action) verifyBlsSign(nodesArry []string, commit *pt.ParacrossCommitAct
 		}
 		pubs = append(pubs, pub)
 	}
-	err := verifyBlsSignPlus(pubs, commit)
+	err := verifyBlsSign(a.exec.cryptoCli, pubs, commit)
 	if err != nil {
 		clog.Error("paracross.Commit bls sign verify", "addr", signAddrs, "nodes", nodesArry, "from", a.fromaddr)
 		return nil, err
@@ -432,14 +432,16 @@ func (a *action) verifyBlsSign(nodesArry []string, commit *pt.ParacrossCommitAct
 	return signAddrs, nil
 }
 
-func verifyBlsSignPlus(pubs []string, commit *pt.ParacrossCommitAction) error {
+func verifyBlsSign(cryptoCli crypto.Crypto, pubs []string, commit *pt.ParacrossCommitAction) error {
 	t1 := types.Now()
-	//单独deserial 90us, g2pubs的公钥结构不好整合到protobuf，就不好压缩到数据库直接读取
-	pubKeys := make([]bls.PublicKey, 0)
+	//1. 获取addr对应的bls 公钥
+	pubKeys := make([]crypto.PubKey, 0)
 	for _, p := range pubs {
-
-		var pub bls.PublicKey
-		err := pub.DeserializeHexStr(p)
+		k, err := common.FromHex(p)
+		if err != nil {
+			return errors.Wrapf(err, "pub FromHex=%s", p)
+		}
+		pub, err := cryptoCli.PubKeyFromBytes(k)
 		if err != nil {
 			return errors.Wrapf(err, "DeserializePublicKey=%s", p)
 		}
@@ -447,21 +449,26 @@ func verifyBlsSignPlus(pubs []string, commit *pt.ParacrossCommitAction) error {
 
 	}
 
-	//3.　获取聚合的签名, deserial 300us
-	var sign bls.Sign
-	err := sign.Deserialize(commit.Bls.Sign)
+	//2.　获取聚合的签名, deserial 300us
+	sign, err := cryptoCli.SignatureFromBytes(commit.Bls.Sign)
 	if err != nil {
 		return errors.Wrapf(err, "DeserializeSignature,key=%s", common.ToHex(commit.Bls.Sign))
 	}
-	//4. 获取签名前原始msg
+	//3. 获取签名前原始msg
 	msg := types.Encode(commit.Status)
-	//verify 1ms, total 2ms
-	if !sign.FastAggregateVerify(pubKeys, msg) {
+
+	//4. verify 1ms, total 2ms
+	agg, err := crypto.ToAggregate(cryptoCli)
+	if err != nil {
+		return errors.Wrap(err, "ToAggregate")
+	}
+	err = agg.VerifyAggregatedOne(pubKeys, msg, sign)
+	if err != nil {
 		clog.Error("paracross.Commit bls sign verify", "title", commit.Status.Title, "height", commit.Status.Height,
 			"addrsMap", common.ToHex(commit.Bls.AddrsMap), "sign", common.ToHex(commit.Bls.Sign), "data", common.ToHex(msg))
 		return pt.ErrBlsSignVerify
 	}
-	clog.Info("paracross verifyBlsSign success", "title", commit.Status.Title, "height", commit.Status.Height, "time", types.Since(t1))
+	clog.Info("paracross procBlsSign success", "title", commit.Status.Title, "height", commit.Status.Height, "time", types.Since(t1))
 	return nil
 }
 
@@ -484,9 +491,9 @@ func (a *action) Commit(commit *pt.ParacrossCommitAction) (*types.Receipt, error
 	//获取commitAddrs, bls sign 包含多个账户的聚合签名
 	commitAddrs := []string{a.fromaddr}
 	if commit.Bls != nil {
-		addrs, err := a.verifyBlsSign(nodesArry, commit)
+		addrs, err := a.procBlsSign(nodesArry, commit)
 		if err != nil {
-			return nil, errors.Wrap(err, "verifyBlsSign")
+			return nil, errors.Wrap(err, "procBlsSign")
 		}
 		commitAddrs = addrs
 	}

plugin/dapp/paracross/executor/paracross.go

@@ -9,22 +9,24 @@ import (
 	"encoding/hex"
 
 	"github.com/33cn/chain33/common"
+	"github.com/33cn/chain33/common/crypto"
 	log "github.com/33cn/chain33/common/log/log15"
 	drivers "github.com/33cn/chain33/system/dapp"
 	"github.com/33cn/chain33/types"
 	"github.com/33cn/chain33/util"
 	pt "github.com/33cn/plugin/plugin/dapp/paracross/types"
-	"github.com/herumi/bls-eth-go-binary/bls"
 )
 
 var (
 	clog                    = log.New("module", "execs.paracross")
 	enableParacrossTransfer = true
 	driverName              = pt.ParaX
+	blsSignName             = "bls"
 )
 
 // Paracross exec
 type Paracross struct {
+	cryptoCli crypto.Crypto
 	drivers.DriverBase
 }
 
@@ -33,7 +35,6 @@ func Init(name string, cfg *types.Chain33Config, sub []byte) {
 	drivers.Register(cfg, GetName(), newParacross, cfg.GetDappFork(driverName, "Enable"))
 	InitExecType()
 	setPrefix()
-	bls.Init(bls.BLS12_381)
 }
 
 func InitExecType() {
@@ -50,6 +51,11 @@ func newParacross() drivers.Driver {
 	c := &Paracross{}
 	c.SetChild(c)
 	c.SetExecutorType(types.LoadExecutorType(driverName))
+	cli, err := crypto.New("bls")
+	if err != nil {
+		panic("paracross need bls sign register")
+	}
+	c.cryptoCli = cli
 	return c
 }
 

plugin/dapp/paracross/executor/paracross_test.go

@@ -20,7 +20,6 @@ import (
 	"github.com/33cn/chain33/types"
 	"github.com/33cn/plugin/plugin/dapp/paracross/testnode"
 	pt "github.com/33cn/plugin/plugin/dapp/paracross/types"
-	"github.com/herumi/bls-eth-go-binary/bls"
 	"github.com/stretchr/testify/assert"
 	"github.com/stretchr/testify/mock"
 	"github.com/stretchr/testify/suite"
@@ -828,7 +827,8 @@ func TestValidParaCrossExec(t *testing.T) {
 }
 
 func TestVerifyBlsSign(t *testing.T) {
-	bls.Init(bls.BLS12_381)
+	cryptoCli, err := crypto.New("bls")
+	assert.NoError(t, err)
 
 	status := &pt.ParacrossNodeStatus{}
 	status.Height = 0
@@ -837,36 +837,42 @@ func TestVerifyBlsSign(t *testing.T) {
 	blsInfo := &pt.ParacrossCommitBlsInfo{}
 	commit := &pt.ParacrossCommitAction{Status: status, Bls: blsInfo}
 
-	PriKS := "0x6da92a632ab7deb67d38c0f6560bcfed28167998f6496db64c258d5e8393a81b"
-	PriJR := "0x19c069234f9d3e61135fefbeb7791b149cdf6af536f26bebb310d4cd22c3fee4"
-	var priKeyKs bls.SecretKey
-	var prikeyJr bls.SecretKey
-	//set hex 支持有0x前缀的，unserial支持无前缀的
-	priKeyKs.SetHexString(PriKS)
-	prikeyJr.SetHexString(PriJR)
-	signKs := priKeyKs.SignByte(msg)
-	signJr := prikeyJr.SignByte(msg)
-	pubKs := priKeyKs.GetPublicKey()
-	pubJr := prikeyJr.GetPublicKey()
-	var si bls.Sign
-	si.Aggregate([]bls.Sign{*signKs, *signJr})
-	pubs := []bls.PublicKey{*pubKs, *pubJr}
-
-	ret := si.FastAggregateVerify(pubs, msg)
-	assert.Equal(t, true, ret)
-
-	blsInfo.Sign = append(blsInfo.Sign, si.Serialize()...)
-	blsInfo.AddrsMap = []byte{0x3}
+	priKSStr := "0x6da92a632ab7deb67d38c0f6560bcfed28167998f6496db64c258d5e8393a81b"
+	p, err := common.FromHex(priKSStr)
+	assert.NoError(t, err)
+	priKS, err := cryptoCli.PrivKeyFromBytes(p)
+	assert.NoError(t, err)
+
+	priJRStr := "0x19c069234f9d3e61135fefbeb7791b149cdf6af536f26bebb310d4cd22c3fee4"
+	p, err = common.FromHex(priJRStr)
+	assert.NoError(t, err)
+	priJR, err := cryptoCli.PrivKeyFromBytes(p)
+	assert.NoError(t, err)
+
+	signKs := priKS.Sign(msg)
+	signJr := priJR.Sign(msg)
+	pubKs := priKS.PubKey()
+	pubJr := priJR.PubKey()
+
+	agg, err := crypto.ToAggregate(cryptoCli)
+	assert.NoError(t, err)
+	aggSigns, err := agg.Aggregate([]crypto.Signature{signKs, signJr})
+	assert.NoError(t, err)
+	pubs := []crypto.PubKey{pubKs, pubJr}
+
+	err = agg.VerifyAggregatedOne(pubs, msg, aggSigns)
+	assert.NoError(t, err)
+
+	blsInfo.Sign = aggSigns.Bytes()
 	PubKS := "a3d97d4186c80268fe6d3689dd574599e25df2dffdcff03f7d8ef64a3bd483241b7d0985958990de2d373d5604caf805"
 	PubJR := "81307df1fdde8f0e846ed1542c859c1e9daba2553e62e48db0877329c5c63fb86e70b9e2e83263da0eb7fcad275857f8"
 	pubKeys := []string{PubJR, PubKS}
-	err := verifyBlsSignPlus(pubKeys, commit)
+	err = verifyBlsSign(cryptoCli, pubKeys, commit)
 	assert.Equal(t, nil, err)
 
-	blsInfo.Sign = signKs.Serialize()
-	blsInfo.AddrsMap = []byte{0x3}
+	blsInfo.Sign = signKs.Bytes()
 	pubKeys = []string{PubKS}
-	err = verifyBlsSignPlus(pubKeys, commit)
+	err = verifyBlsSign(cryptoCli, pubKeys, commit)
 	assert.Equal(t, nil, err)
 
 }