ceremonyclient/nekryptology/pkg/sharing/feldman.go
2023-07-05 00:32:28 -05:00

113 lines
2.6 KiB
Go

//
// Copyright Coinbase, Inc. All Rights Reserved.
//
// SPDX-License-Identifier: Apache-2.0
//
package sharing
import (
"fmt"
"io"
"source.quilibrium.com/quilibrium/monorepo/nekryptology/pkg/core/curves"
)
type FeldmanVerifier struct {
Commitments []curves.Point
}
func (v FeldmanVerifier) Verify(share *ShamirShare) error {
curve := curves.GetCurveByName(v.Commitments[0].CurveName())
err := share.Validate(curve)
if err != nil {
return err
}
x := curve.Scalar.New(int(share.Id))
i := curve.Scalar.One()
rhs := v.Commitments[0]
for j := 1; j < len(v.Commitments); j++ {
i = i.Mul(x)
rhs = rhs.Add(v.Commitments[j].Mul(i))
}
sc, _ := curve.Scalar.SetBytes(share.Value)
lhs := v.Commitments[0].Generator().Mul(sc)
if lhs.Equal(rhs) {
return nil
} else {
return fmt.Errorf("not equal")
}
}
type Feldman struct {
Threshold, Limit uint32
Curve *curves.Curve
}
func NewFeldman(threshold, limit uint32, curve *curves.Curve) (*Feldman, error) {
if limit < threshold {
return nil, fmt.Errorf("limit cannot be less than threshold")
}
if threshold < 2 {
return nil, fmt.Errorf("threshold cannot be less than 2")
}
if limit > 255 {
return nil, fmt.Errorf("cannot exceed 255 shares")
}
if curve == nil {
return nil, fmt.Errorf("invalid curve")
}
return &Feldman{threshold, limit, curve}, nil
}
func (f Feldman) Split(secret curves.Scalar, reader io.Reader) (*FeldmanVerifier, []*ShamirShare, error) {
if secret.IsZero() {
return nil, nil, fmt.Errorf("invalid secret")
}
shamir := &Shamir{
threshold: f.Threshold,
limit: f.Limit,
curve: f.Curve,
}
shares, poly := shamir.getPolyAndShares(secret, reader)
verifier := new(FeldmanVerifier)
verifier.Commitments = make([]curves.Point, f.Threshold)
for i := range verifier.Commitments {
verifier.Commitments[i] = f.Curve.ScalarBaseMult(poly.Coefficients[i])
}
return verifier, shares, nil
}
func (f Feldman) LagrangeCoeffs(shares map[uint32]*ShamirShare) (map[uint32]curves.Scalar, error) {
shamir := &Shamir{
threshold: f.Threshold,
limit: f.Limit,
curve: f.Curve,
}
identities := make([]uint32, 0)
for _, xi := range shares {
identities = append(identities, xi.Id)
}
return shamir.LagrangeCoeffs(identities)
}
func (f Feldman) Combine(shares ...*ShamirShare) (curves.Scalar, error) {
shamir := &Shamir{
threshold: f.Threshold,
limit: f.Limit,
curve: f.Curve,
}
return shamir.Combine(shares...)
}
func (f Feldman) CombinePoints(shares ...*ShamirShare) (curves.Point, error) {
shamir := &Shamir{
threshold: f.Threshold,
limit: f.Limit,
curve: f.Curve,
}
return shamir.CombinePoints(shares...)
}