Add marshalling for deal

internal/v3marshaling.go

@@ -0,0 +1,57 @@
+package internal
+
+import (
+	"fmt"
+	"math"
+	"reflect"
+
+	"go.dedis.ch/kyber/v4"
+	"go.dedis.ch/kyber/v4/internal/protobuf"
+	"go.dedis.ch/kyber/v4/share"
+)
+
+// Suite defines the capabilities required by the v3marshalling package.
+type Suite interface {
+	// Group is needed for Group.Scalar
+	kyber.Group
+}
+
+// compatiblePriShare is a struct for PriShare used when marshaling to
+// ensure compatibility with V3
+type compatiblePriShare struct {
+	I int64
+	V kyber.Scalar
+}
+
+// MarshalPriShare marshals a share.PriShare into bytes or returns an error
+// if the encoding did not work. Encoding is compatible with Kyber V3
+func MarshalPriShare(priShare *share.PriShare) ([]byte, error) {
+	toEncode := &compatiblePriShare{
+		I: int64(priShare.I),
+		V: priShare.V,
+	}
+	return protobuf.Encode(toEncode)
+}
+
+// UnmarshalPriShare unmarshals a share.PriShare from bytes or returns an error
+// if the decoding did not work. Decoding is compatible with Kyber V3
+func UnmarshalPriShare(data []byte, suite Suite) (*share.PriShare, error) {
+	compatiblePriShare := &compatiblePriShare{}
+	constructors := make(protobuf.Constructors)
+	constructors[reflect.TypeFor[kyber.Scalar]()] = func() interface{} { return suite.Scalar() }
+	err := protobuf.DecodeWithConstructors(data, compatiblePriShare, constructors)
+
+	// Check for overflow on I
+	if compatiblePriShare.I < 0 || compatiblePriShare.I > math.MaxUint32 {
+		return nil, fmt.Errorf("cannot cast I as int64 to uint32 due to overflow")
+	}
+
+	if err != nil {
+		return nil, err
+	}
+	priShare := &share.PriShare{
+		I: uint32(compatiblePriShare.I),
+		V: compatiblePriShare.V,
+	}
+	return priShare, nil
+}

share/dkg/rabin/dkg.go

@@ -42,7 +42,6 @@ import (
 	"fmt"
 
 	"go.dedis.ch/kyber/v4"
-	"go.dedis.ch/kyber/v4/internal/protobuf"
 	"go.dedis.ch/kyber/v4/share"
 	vss "go.dedis.ch/kyber/v4/share/vss/rabin"
 	"go.dedis.ch/kyber/v4/sign/schnorr"
@@ -681,7 +680,7 @@ func (cc *ComplaintCommits) Hash(s Suite) []byte {
 	_, _ = h.Write([]byte("commitcomplaint"))
 	_ = binary.Write(h, binary.LittleEndian, cc.Index)
 	_ = binary.Write(h, binary.LittleEndian, cc.DealerIndex)
-	buff, _ := protobuf.Encode(cc.Deal)
+	buff, _ := cc.Deal.Marshal()
 	_, _ = h.Write(buff)
 	return h.Sum(nil)
 }

share/vss/pedersen/vss.go

@@ -12,6 +12,7 @@ import (
 	"reflect"
 
 	"go.dedis.ch/kyber/v4"
+	"go.dedis.ch/kyber/v4/internal"
 	"go.dedis.ch/kyber/v4/internal/protobuf"
 	"go.dedis.ch/kyber/v4/share"
 	"go.dedis.ch/kyber/v4/sign/schnorr"
@@ -58,6 +59,53 @@ type Deal struct {
 	Commitments []kyber.Point
 }
 
+// pedersenCompatibleDeal is a struct for Deal used when marshaling
+// to ensure compatibility with Kyber V3.
+type pedersenCompatibleDeal struct {
+	SessionID   []byte
+	SecShare    []byte
+	T           uint32
+	Commitments []kyber.Point
+}
+
+// Marshal marshals a Deal into bytes or return an error if encoding failed.
+// This encoding should always be preferred as it is compatible with Kyber V3.
+func (d *Deal) Marshal() ([]byte, error) {
+	secShareBytes, err := internal.MarshalPriShare(d.SecShare)
+	if err != nil {
+		return nil, err
+	}
+	compatibleDeal := &pedersenCompatibleDeal{
+		SessionID:   d.SessionID,
+		SecShare:    secShareBytes,
+		T:           d.T,
+		Commitments: d.Commitments,
+	}
+	return protobuf.Encode(compatibleDeal)
+}
+
+// Unmarshal unmarshals a Deal from bytes or return an error if decoding failed.
+// This decoding should always be preferred as it is compatible with Kyber V3.
+func (d *Deal) Unmarshal(data []byte, suite Suite) error {
+	compatibleDeal := &pedersenCompatibleDeal{}
+	constructors := make(protobuf.Constructors)
+	constructors[reflect.TypeFor[kyber.Point]()] = func() interface{} { return suite.Point() }
+	err := protobuf.DecodeWithConstructors(data, compatibleDeal, constructors)
+	if err != nil {
+		return err
+	}
+	secShare, err := internal.UnmarshalPriShare(compatibleDeal.SecShare, suite)
+	if err != nil {
+		return err
+	}
+
+	d.SessionID = compatibleDeal.SessionID
+	d.T = compatibleDeal.T
+	d.SecShare = secShare
+	d.Commitments = compatibleDeal.Commitments
+	return nil
+}
+
 // EncryptedDeal contains the deal in a encrypted form only decipherable by the
 // correct recipient. The encryption is performed in a similar manner as what is
 // done in TLS. The dealer generates a temporary key pair, signs it with its
@@ -67,7 +115,7 @@ type EncryptedDeal struct {
 	DHKey []byte
 	// Signature of the DH key by the longterm key of the dealer
 	Signature []byte
-	// AEAD encryption of the deal marshalled by protobuf
+	// AEAD encryption of the deal marshalled
 	Cipher []byte
 }
 
@@ -193,7 +241,7 @@ func (d *Dealer) EncryptedDeal(i int) (*EncryptedDeal, error) {
 	}
 
 	nonce := make([]byte, gcm.NonceSize())
-	dealBuff, err := protobuf.Encode(d.deals[i])
+	dealBuff, err := d.deals[i].Marshal()
 	if err != nil {
 		return nil, err
 	}
@@ -408,7 +456,7 @@ func (v *Verifier) decryptDeal(e *EncryptedDeal) (*Deal, error) {
 		return nil, err
 	}
 	deal := &Deal{}
-	err = deal.decode(v.suite, decrypted)
+	err = deal.Unmarshal(decrypted, v.suite)
 	return deal, err
 }
 
@@ -772,22 +820,13 @@ func (r *Response) Hash(s Suite) []byte {
 	return h.Sum(nil)
 }
 
-func (d *Deal) decode(s Suite, buff []byte) error {
-	constructors := make(protobuf.Constructors)
-	var point kyber.Point
-	var secret kyber.Scalar
-	constructors[reflect.TypeOf(&point).Elem()] = func() interface{} { return s.Point() }
-	constructors[reflect.TypeOf(&secret).Elem()] = func() interface{} { return s.Scalar() }
-	return protobuf.DecodeWithConstructors(buff, d, constructors)
-}
-
 // Hash returns the hash of a Justification.
 func (j *Justification) Hash(s Suite) []byte {
 	h := s.Hash()
 	_, _ = h.Write([]byte("justification"))
 	_, _ = h.Write(j.SessionID)
 	_ = binary.Write(h, binary.LittleEndian, j.Index)
-	buff, _ := protobuf.Encode(j.Deal)
+	buff, _ := j.Deal.Marshal()
 	_, _ = h.Write(buff)
 	return h.Sum(nil)
 }

share/vss/rabin/vss.go

@@ -38,6 +38,7 @@ import (
 	"reflect"
 
 	"go.dedis.ch/kyber/v4"
+	"go.dedis.ch/kyber/v4/internal"
 	"go.dedis.ch/kyber/v4/internal/protobuf"
 	"go.dedis.ch/kyber/v4/share"
 	"go.dedis.ch/kyber/v4/sign/schnorr"
@@ -86,6 +87,65 @@ type Deal struct {
 	Commitments []kyber.Point
 }
 
+// rabinCompatibleDeal is a struct for Deal used when marshaling
+// to ensure compatibility with Kyber V3.
+type rabinCompatibleDeal struct {
+	SessionID   []byte
+	SecShare    []byte
+	RndShare    []byte
+	T           uint32
+	Commitments []kyber.Point
+}
+
+// Marshal marshals a Deal into bytes or return an error if encoding failed.
+// This encoding should always be preferred as it is compatible with Kyber V3.
+func (deal *Deal) Marshal() ([]byte, error) {
+	secShareBytes, err := internal.MarshalPriShare(deal.SecShare)
+	if err != nil {
+		return nil, err
+	}
+	rndShareBytes, err := internal.MarshalPriShare(deal.RndShare)
+	if err != nil {
+		return nil, err
+	}
+	compatibleDeal := &rabinCompatibleDeal{
+		SessionID:   deal.SessionID,
+		SecShare:    secShareBytes,
+		RndShare:    rndShareBytes,
+		T:           deal.T,
+		Commitments: deal.Commitments,
+	}
+	return protobuf.Encode(compatibleDeal)
+}
+
+// Unmarshal unmarshals a Deal from bytes or return an error if decoding failed.
+// This decoding should always be preferred as it is compatible with Kyber V3.
+func (deal *Deal) Unmarshal(data []byte, suite Suite) error {
+	compatibleDeal := &rabinCompatibleDeal{}
+	constructors := make(protobuf.Constructors)
+	constructors[reflect.TypeFor[kyber.Point]()] = func() interface{} { return suite.Point() }
+	err := protobuf.DecodeWithConstructors(data, compatibleDeal, constructors)
+	if err != nil {
+		return err
+	}
+
+	secShare, err := internal.UnmarshalPriShare(compatibleDeal.SecShare, suite)
+	if err != nil {
+		return err
+	}
+
+	rndShare, err := internal.UnmarshalPriShare(compatibleDeal.RndShare, suite)
+	if err != nil {
+		return err
+	}
+	deal.SessionID = compatibleDeal.SessionID
+	deal.SecShare = secShare
+	deal.RndShare = rndShare
+	deal.T = compatibleDeal.T
+	deal.Commitments = compatibleDeal.Commitments
+	return nil
+}
+
 // EncryptedDeal contains the deal in a encrypted form only decipherable by the
 // correct recipient. The encryption is performed in a similar manner as what is
 // done in TLS. The dealer generates a temporary key pair, signs it with its
@@ -95,7 +155,7 @@ type EncryptedDeal struct {
 	DHKey kyber.Point
 	// Signature of the DH key by the longterm key of the dealer
 	Signature []byte
-	// AEAD encryption of the deal marshalled by protobuf
+	// AEAD encryption of the deal marshalled
 	Cipher []byte
 }
 
@@ -222,7 +282,7 @@ func (d *Dealer) EncryptedDeal(i int) (*EncryptedDeal, error) {
 	}
 
 	nonce := make([]byte, gcm.NonceSize())
-	dealBuff, err := protobuf.Encode(d.deals[i])
+	dealBuff, err := d.deals[i].Marshal()
 	if err != nil {
 		return nil, err
 	}
@@ -438,7 +498,7 @@ func (v *Verifier) decryptDeal(e *EncryptedDeal) (*Deal, error) {
 		return nil, err
 	}
 	deal := &Deal{}
-	err = deal.decode(v.suite, decrypted)
+	err = deal.Unmarshal(decrypted, v.suite)
 	return deal, err
 }
 
@@ -763,22 +823,13 @@ func (r *Response) Hash(s Suite) []byte {
 	return h.Sum(nil)
 }
 
-func (d *Deal) decode(s Suite, buff []byte) error {
-	constructors := make(protobuf.Constructors)
-	var point kyber.Point
-	var secret kyber.Scalar
-	constructors[reflect.TypeOf(&point).Elem()] = func() interface{} { return s.Point() }
-	constructors[reflect.TypeOf(&secret).Elem()] = func() interface{} { return s.Scalar() }
-	return protobuf.DecodeWithConstructors(buff, d, constructors)
-}
-
 // Hash returns the hash of a Justification.
 func (j *Justification) Hash(s Suite) []byte {
 	h := s.Hash()
 	_, _ = h.Write([]byte("justification"))
 	_, _ = h.Write(j.SessionID)
 	_ = binary.Write(h, binary.LittleEndian, j.Index)
-	buff, _ := protobuf.Encode(j.Deal)
+	buff, _ := j.Deal.Marshal()
 	_, _ = h.Write(buff)
 	return h.Sum(nil)
 }