No commit suggestions generated

dkg/gennaro2p/README.md

@@ -0,0 +1,12 @@
+---
+aliases: [README]
+tags: []
+title: README
+linter-yaml-title-alias: README
+date created: Wednesday, April 17th 2024, 4:11:40 pm
+date modified: Thursday, April 18th 2024, 8:19:25 am
+---
+
+## Two-party GG20
+
+This package wraps dkg/genarro and specializes it for the 2-party case.

dkg/gennaro2p/genarro2p.go

@@ -0,0 +1,151 @@
+//
+// Copyright Coinbase, Inc. All Rights Reserved.
+//
+// SPDX-License-Identifier: Apache-2.0
+//
+
+// Package gennaro2p wraps dkg/genarro and specializes it for the 2-party case. Simpler API, no
+// distinction between broadcast and peer messages, and only counterparty messages are
+// used as round inputs since self-inputs are always ignored.
+package gennaro2p
+
+import (
+	"crypto/elliptic"
+	"fmt"
+
+	"github.com/pkg/errors"
+
+	"github.com/sonr-io/sonr/crypto/core/curves"
+	"github.com/sonr-io/sonr/crypto/dkg/gennaro"
+	v1 "github.com/sonr-io/sonr/crypto/sharing/v1"
+)
+
+const threshold = 2
+
+// Participant is a DKG player that contains information needed to perform DKG rounds
+// and yield a secret key share and public key when finished
+type Participant struct {
+	id             uint32
+	counterPartyId uint32
+	embedded       *gennaro.Participant
+	blind          *curves.EcPoint
+}
+
+type Round1Message struct {
+	Verifiers     []*v1.ShareVerifier
+	SecretShare   *v1.ShamirShare
+	BlindingShare *v1.ShamirShare
+	Blind         *curves.EcPoint
+}
+
+type Round2Message struct {
+	Verifiers []*v1.ShareVerifier
+}
+
+type DkgResult struct {
+	PublicKey    *curves.EcPoint
+	SecretShare  *v1.ShamirShare
+	PublicShares map[uint32]*curves.EcPoint
+}
+
+// NewParticipant creates a participant ready to perform a DKG
+// blind must be a generator and must be synchronized between counterparties.
+// The first participant can set it to `nil` and a secure blinding factor will be
+// generated.
+func NewParticipant(id, counterPartyId uint32, blind *curves.EcPoint,
+	scalar curves.EcScalar, curve elliptic.Curve,
+) (*Participant, error) {
+	// Generate blinding value, if required
+	var err error
+	if blind == nil {
+		blind, err = newBlind(scalar, curve)
+		if err != nil {
+			return nil, errors.Wrap(err, "generating fresh blinding generator")
+		}
+	}
+	p, err := gennaro.NewParticipant(id, threshold, blind, scalar, counterPartyId)
+	if err != nil {
+		return nil, errors.Wrap(err, "created genarro.Participant")
+	}
+	return &Participant{id, counterPartyId, p, blind}, nil
+}
+
+// Creates a random blinding factor (as a generator) required for pedersen's VSS
+func newBlind(curveScalar curves.EcScalar, curve elliptic.Curve) (*curves.EcPoint, error) {
+	rScalar, err := curveScalar.Random()
+	if err != nil {
+		return nil, errors.Wrap(err, "generating blinding scalar")
+	}
+	return curves.NewScalarBaseMult(curve, rScalar)
+}
+
+// Runs DKG round 1. If `secret` is nil, shares of a new, random signing key are generated.
+// Otherwise, the existing secret shares will be refreshed but the privkey and pubkey
+// will remain unchanged.
+func (p *Participant) Round1(secret []byte) (*Round1Message, error) {
+	// Run round 1
+	bcast, p2p, err := p.embedded.Round1(secret)
+	if err != nil {
+		return nil, errors.Wrap(err, "calling embedded.Round1()")
+	}
+
+	// Ensure the map has the expected entry so there's no SIGSEGV when we
+	// repackage it
+	if p2p[p.counterPartyId] == nil {
+		return nil, fmt.Errorf("round1 response for p2p[%v] is nil", p.counterPartyId)
+	}
+
+	// Package response
+	return &Round1Message{
+		bcast,
+		p2p[p.counterPartyId].SecretShare,
+		p2p[p.counterPartyId].BlindingShare,
+		p.blind,
+	}, nil
+}
+
+// Runs DKG round 2 using the counterparty's output from round 1.
+func (p *Participant) Round2(msg *Round1Message) (*Round2Message, error) {
+	// Run round 2
+	bcast, err := p.embedded.Round2(
+		map[uint32]gennaro.Round1Bcast{
+			p.counterPartyId: msg.Verifiers,
+		},
+		map[uint32]*gennaro.Round1P2PSendPacket{
+			p.counterPartyId: {
+				SecretShare:   msg.SecretShare,
+				BlindingShare: msg.BlindingShare,
+			},
+		})
+	if err != nil {
+		return nil, errors.Wrap(err, "calling embedded.Round2()")
+	}
+
+	// Package response
+	return &Round2Message{bcast}, nil
+}
+
+// Completes the DKG using the counterparty's output from round 2.
+func (p *Participant) Finalize(msg *Round2Message) (*DkgResult, error) {
+	// Run round 3
+	pk, share, err := p.embedded.Round3(
+		map[uint32]gennaro.Round2Bcast{
+			p.counterPartyId: msg.Verifiers,
+		})
+	if err != nil {
+		return nil, errors.Wrap(err, "calling embedded.Round3()")
+	}
+
+	// Compute public shares
+	pubShares, err := p.embedded.Round4()
+	if err != nil {
+		return nil, errors.Wrap(err, "calling embedded.Roun4()")
+	}
+
+	// Package response
+	return &DkgResult{
+		PublicKey:    pk,
+		SecretShare:  share,
+		PublicShares: pubShares,
+	}, nil
+}

dkg/gennaro2p/genarro2p_test.go

@@ -0,0 +1,181 @@
+//
+// Copyright Coinbase, Inc. All Rights Reserved.
+//
+// SPDX-License-Identifier: Apache-2.0
+//
+
+package gennaro2p
+
+import (
+	"crypto/elliptic"
+	"fmt"
+	"reflect"
+	"testing"
+
+	"github.com/btcsuite/btcd/btcec/v2"
+	"github.com/stretchr/testify/require"
+
+	"github.com/sonr-io/sonr/crypto/core/curves"
+	v1 "github.com/sonr-io/sonr/crypto/sharing/v1"
+)
+
+var (
+	curveScalar = curves.NewK256Scalar()
+	curve       = btcec.S256()
+)
+
+const (
+	clientId = 1
+	serverId = 2
+)
+
+// Benchmark full DKG including blind selection and setup
+func BenchmarkDkg(b *testing.B) {
+	if testing.Short() {
+		b.Skip("skipping test in short mode.")
+	}
+
+	for i := 0; i < b.N; i++ {
+		_, _, err := dkg()
+		require.NoError(b, err)
+	}
+}
+
+// Run a DKG and reports the client/server results
+func dkg() (*DkgResult, *DkgResult, error) {
+	// Create client/server
+	blind, _ := newBlind(curveScalar, curve)
+
+	client, err := NewParticipant(clientId, serverId, blind, curveScalar, curve)
+	if err != nil {
+		return nil, nil, err
+	}
+
+	server, err := NewParticipant(serverId, clientId, blind, curveScalar, curve)
+	if err != nil {
+		return nil, nil, err
+	}
+
+	// R1
+	clientR1, err := client.Round1(nil)
+	if err != nil {
+		return nil, nil, err
+	}
+
+	serverR1, err := server.Round1(nil)
+	if err != nil {
+		return nil, nil, err
+	}
+
+	// R2
+	clientR2, err := client.Round2(serverR1)
+	if err != nil {
+		return nil, nil, err
+	}
+
+	serverR2, err := server.Round2(clientR1)
+	if err != nil {
+		return nil, nil, err
+	}
+
+	// Finalize
+	clientResult, err := client.Finalize(serverR2)
+	if err != nil {
+		return nil, nil, err
+	}
+
+	serverResult, err := server.Finalize(clientR2)
+	if err != nil {
+		return nil, nil, err
+	}
+
+	return clientResult, serverResult, nil
+}
+
+// Run a full DKG and verify the absence of errors and valid results
+func TestDkg(t *testing.T) {
+	// Setup and ensure no errors
+	clientResult, serverResult, err := dkg()
+	require.NoError(t, err)
+	require.NotNil(t, clientResult)
+	require.NotNil(t, serverResult)
+
+	// Now run tests
+	t.Run("produce the same public key", func(t *testing.T) {
+		require.Equal(t, clientResult.PublicKey, serverResult.PublicKey)
+	})
+	t.Run("produce identical public shares", func(t *testing.T) {
+		require.True(t, reflect.DeepEqual(clientResult.PublicShares, serverResult.PublicShares))
+	})
+	t.Run("produce distinct secret shares", func(t *testing.T) {
+		require.NotEqual(t, clientResult.SecretShare, serverResult.SecretShare)
+	})
+	t.Run("produce distinct secret shares", func(t *testing.T) {
+		require.NotEqual(t, clientResult.SecretShare, serverResult.SecretShare)
+	})
+	t.Run("shares sum to expected public key", func(t *testing.T) {
+		pubkey, err := reconstructPubkey(
+			clientResult.SecretShare,
+			serverResult.SecretShare,
+			curve)
+		require.NoError(t, err)
+		require.Equal(t, serverResult.PublicKey, pubkey)
+	})
+}
+
+// Reconstruct the pubkey from 2 shares
+func reconstructPubkey(s1, s2 *v1.ShamirShare, curve elliptic.Curve) (*curves.EcPoint, error) {
+	s, err := v1.NewShamir(2, 2, s1.Value.Field())
+	if err != nil {
+		return nil, err
+	}
+
+	sk, err := s.Combine(s1, s2)
+	if err != nil {
+		return nil, err
+	}
+
+	x, y := curve.ScalarBaseMult(sk)
+	return &curves.EcPoint{
+		Curve: curve,
+		X:     x,
+		Y:     y,
+	}, nil
+}
+
+// Test blind generator helper function produces a value on the expected curve
+func TestNewBlindOnCurve(t *testing.T) {
+	const n = 1024
+	for i := 0; i < n; i++ {
+		b, err := newBlind(curveScalar, curve)
+		require.NoError(t, err)
+		require.NotNil(t, b)
+
+		// Valid point?
+		require.True(t, b.IsOnCurve() && b.IsValid())
+		require.True(t, b.IsValid())
+		require.False(t, b.IsIdentity())
+		require.False(t, b.IsBasePoint())
+	}
+}
+
+func TestNewBlindProvidesDistinctPoints(t *testing.T) {
+	const n = 1024
+	seen := make(map[string]bool, n)
+	// seen := make(map[core.EcPoint]bool, n)
+
+	for i := 0; i < n; i++ {
+		b, err := newBlind(curveScalar, curve)
+		require.NoError(t, err)
+
+		// serialize so the point is hashable
+		txt := fmt.Sprintf("%#v", b)
+
+		// We shouldn't see the same point twice
+		ok := seen[txt]
+		require.False(t, ok)
+
+		// store
+		seen[txt] = true
+	}
+}