adds VerifyCollectiveBeacon and GetRandomness

go.mod

@@ -5,6 +5,8 @@ go 1.14
 require (
 	github.com/dgraph-io/badger/v2 v2.0.2
 	github.com/dgrijalva/jwt-go v3.2.0+incompatible
+	github.com/drand/drand v0.5.3
+	github.com/drand/kyber v1.0.1-0.20200110225416-8de27ed8c0e2
 	github.com/gobuffalo/packr/v2 v2.7.1
 	github.com/golang/protobuf v1.3.4
 	github.com/googollee/go-engine.io v1.4.3-0.20190924125625-798118fc0dd2

packages/binary/drng/drng.go

+package drng
+
+import (
+	"crypto/sha512"
+	"errors"
+
+	"github.com/drand/drand/beacon"
+	"github.com/drand/drand/key"
+	"github.com/iotaledger/goshimmer/packages/binary/drng/payload/collectiveBeacon"
+)
+
+// VerifyCollectiveBeacon checks the current signature against the distributed public key
+func VerifyCollectiveBeacon(data *collectiveBeacon.Payload) error {
+	if data == nil {
+		return errors.New("nil data")
+	}
+
+	dpk := key.KeyGroup.Point()
+	if err := dpk.UnmarshalBinary(data.DistributedPK()); err != nil {
+		return err
+	}
+
+	msg := beacon.Message(data.PrevSignature(), data.Round())
+
+	if err := key.Scheme.VerifyRecovered(dpk, msg, data.Signature()); err != nil {
+		return err
+	}
+
+	return nil
+}
+
+// GetRandomness returns the randomness from a given signature
+func GetRandomness(signature []byte) ([]byte, error) {
+	hash := sha512.New()
+	if _, err := hash.Write(signature); err != nil {
+		return nil, err
+	}
+
+	//return hash, nil
+	return hash.Sum(nil), nil
+}

packages/binary/drng/drng_test.go

+package drng
+
+import (
+	"testing"
+
+	"github.com/drand/drand/beacon"
+	"github.com/drand/drand/key"
+	"github.com/drand/kyber/share"
+	"github.com/drand/kyber/util/random"
+	"github.com/iotaledger/goshimmer/packages/binary/drng/payload/collectiveBeacon"
+	"github.com/stretchr/testify/require"
+)
+
+func TestVerifyCollectiveBeacon(t *testing.T) {
+	payload := dkgShares(t, 5, 3)
+	err := VerifyCollectiveBeacon(payload)
+	require.NoError(t, err)
+}
+
+func TestGetRandomness(t *testing.T) {
+	payload := dkgShares(t, 5, 3)
+	_, err := GetRandomness(payload.Signature())
+	require.NoError(t, err)
+}
+
+func dkgShares(t *testing.T, n, threshold int) *collectiveBeacon.Payload {
+	var priPoly *share.PriPoly
+	var pubPoly *share.PubPoly
+	var err error
+	// create shares and committments
+	for i := 0; i < n; i++ {
+		pri := share.NewPriPoly(key.KeyGroup, threshold, key.KeyGroup.Scalar().Pick(random.New()), random.New())
+		pub := pri.Commit(key.KeyGroup.Point().Base())
+		if priPoly == nil {
+			priPoly = pri
+			pubPoly = pub
+			continue
+		}
+		priPoly, err = priPoly.Add(pri)
+		require.NoError(t, err)
+
+		pubPoly, err = pubPoly.Add(pub)
+		require.NoError(t, err)
+	}
+	shares := priPoly.Shares(n)
+	secret, err := share.RecoverSecret(key.KeyGroup, shares, threshold, n)
+	require.NoError(t, err)
+	require.True(t, secret.Equal(priPoly.Secret()))
+
+	msg := []byte("first message")
+	sigs := make([][]byte, n, n)
+	_, commits := pubPoly.Info()
+	dkgShares := make([]*key.Share, n, n)
+
+	// partial signatures
+	for i := 0; i < n; i++ {
+		sigs[i], err = key.Scheme.Sign(shares[i], msg)
+		require.NoError(t, err)
+
+		dkgShares[i] = &key.Share{
+			Share:   shares[i],
+			Commits: commits,
+		}
+	}
+
+	// reconstruct collective signature
+	sig, err := key.Scheme.Recover(pubPoly, msg, sigs, threshold, n)
+	require.NoError(t, err)
+
+	// verify signature against distributed public key
+	err = key.Scheme.VerifyRecovered(pubPoly.Commit(), msg, sig)
+	require.NoError(t, err)
+
+	msg = beacon.Message(sig, 1)
+	sigs = make([][]byte, n, n)
+	// partial signatures
+	for i := 0; i < n; i++ {
+		sigs[i], err = key.Scheme.Sign(shares[i], msg)
+		require.NoError(t, err)
+	}
+
+	// reconstruct collective signature
+	newSig, err := key.Scheme.Recover(pubPoly, msg, sigs, threshold, n)
+	require.NoError(t, err)
+
+	dpk, err := pubPoly.Commit().MarshalBinary()
+	require.NoError(t, err)
+
+	return collectiveBeacon.New(1, 1, sig, newSig, dpk)
+}

packages/binary/drng/payload/collectiveBeacon/collective_beacon_test.go

@@ -12,9 +12,9 @@ func TestParse(t *testing.T) {
 	header := header.New(header.CollectiveBeaconType(), 0)
 	payload := New(header.Instance(),
 		0,
-		[]byte("AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA"), // prevSignature
-		[]byte("BBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBB"), // signature
-		[]byte("CCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCC")) // distributed PK
+		[]byte("AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA"), // prevSignature
+		[]byte("BBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBB"), // signature
+		[]byte("CCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCC"))                                                 // distributed PK
 	bytes := payload.Bytes()
 
 	marshalUtil := marshalutil.New(bytes)

packages/binary/drng/payload/collectiveBeacon/common.go

@@ -2,7 +2,7 @@ package collectiveBeacon
 
 const (
 	// BLS Signature size in bytes
-	SignatureSize = 32
+	SignatureSize = 96
 	// BLS Public Key size in bytes
-	PublicKeySize = 32
+	PublicKeySize = 48
 )