mirror of
https://source.quilibrium.com/quilibrium/ceremonyclient.git
synced 2024-11-14 04:05:17 +00:00
519 lines
12 KiB
Go
519 lines
12 KiB
Go
|
//
|
|||
|
|
// Copyright Coinbase, Inc. All Rights Reserved.
|
|||
|
|
//
|
|||
|
|
// SPDX-License-Identifier: Apache-2.0
|
|||
|
|
//
|
|||
|
|
|
|||
|
|
package accumulator
|
|||
|
|
|
|||
|
|
import (
|
|||
|
|
"bytes"
|
|||
|
|
crand "crypto/rand"
|
|||
|
|
"errors"
|
|||
|
|
"fmt"
|
|||
|
|
|
|||
|
|
"git.sr.ht/~sircmpwn/go-bare"
|
|||
|
|
|
|||
|
|
"source.quilibrium.com/quilibrium/monorepo/nekryptology/pkg/core/curves"
|
|||
|
|
)
|
|||
|
|
|
|||
|
|
type proofParamsMarshal struct {
|
|||
|
|
X []byte `bare:"x"`
|
|||
|
|
Y []byte `bare:"y"`
|
|||
|
|
Z []byte `bare:"z"`
|
|||
|
|
Curve string `bare:"curve"`
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
// ProofParams contains four distinct public generators of G1 - X, Y, Z
|
|||
|
|
type ProofParams struct {
|
|||
|
|
x, y, z curves.Point
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
// New samples X, Y, Z, K
|
|||
|
|
func (p *ProofParams) New(curve *curves.PairingCurve, pk *PublicKey, entropy []byte) (*ProofParams, error) {
|
|||
|
|
pkBytes, err := pk.MarshalBinary()
|
|||
|
|
if err != nil {
|
|||
|
|
return nil, err
|
|||
|
|
}
|
|||
|
|
prefix := bytes.Repeat([]byte{0xFF}, 32)
|
|||
|
|
data := append(prefix, entropy...)
|
|||
|
|
data = append(data, pkBytes...)
|
|||
|
|
p.z = curve.Scalar.Point().Hash(data)
|
|||
|
|
|
|||
|
|
data[0] = 0xFE
|
|||
|
|
p.y = curve.Scalar.Point().Hash(data)
|
|||
|
|
|
|||
|
|
data[0] = 0xFD
|
|||
|
|
p.x = curve.Scalar.Point().Hash(data)
|
|||
|
|
|
|||
|
|
return p, nil
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
// MarshalBinary converts ProofParams to bytes
|
|||
|
|
func (p *ProofParams) MarshalBinary() ([]byte, error) {
|
|||
|
|
if p.x == nil || p.y == nil || p.z == nil {
|
|||
|
|
return nil, fmt.Errorf("some value x, y, or z is nil")
|
|||
|
|
}
|
|||
|
|
tv := &proofParamsMarshal{
|
|||
|
|
X: p.x.ToAffineCompressed(),
|
|||
|
|
Y: p.y.ToAffineCompressed(),
|
|||
|
|
Z: p.z.ToAffineCompressed(),
|
|||
|
|
Curve: p.x.CurveName(),
|
|||
|
|
}
|
|||
|
|
return bare.Marshal(tv)
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
// UnmarshalBinary converts bytes to ProofParams
|
|||
|
|
func (p *ProofParams) UnmarshalBinary(data []byte) error {
|
|||
|
|
if data == nil {
|
|||
|
|
return fmt.Errorf("expected non-zero byte sequence")
|
|||
|
|
}
|
|||
|
|
tv := new(proofParamsMarshal)
|
|||
|
|
err := bare.Unmarshal(data, tv)
|
|||
|
|
if err != nil {
|
|||
|
|
return err
|
|||
|
|
}
|
|||
|
|
curve := curves.GetCurveByName(tv.Curve)
|
|||
|
|
if curve == nil {
|
|||
|
|
return fmt.Errorf("invalid curve")
|
|||
|
|
}
|
|||
|
|
x, err := curve.NewIdentityPoint().FromAffineCompressed(tv.X)
|
|||
|
|
if err != nil {
|
|||
|
|
return err
|
|||
|
|
}
|
|||
|
|
y, err := curve.NewIdentityPoint().FromAffineCompressed(tv.Y)
|
|||
|
|
if err != nil {
|
|||
|
|
return err
|
|||
|
|
}
|
|||
|
|
z, err := curve.NewIdentityPoint().FromAffineCompressed(tv.Z)
|
|||
|
|
if err != nil {
|
|||
|
|
return err
|
|||
|
|
}
|
|||
|
|
p.x = x
|
|||
|
|
p.y = y
|
|||
|
|
p.z = z
|
|||
|
|
return nil
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
// MembershipProofCommitting contains value computed in Proof of knowledge and
|
|||
|
|
// Blinding phases as described in section 7 of https://eprint.iacr.org/2020/777.pdf
|
|||
|
|
type MembershipProofCommitting struct {
|
|||
|
|
eC curves.Point
|
|||
|
|
tSigma curves.Point
|
|||
|
|
tRho curves.Point
|
|||
|
|
deltaSigma curves.Scalar
|
|||
|
|
deltaRho curves.Scalar
|
|||
|
|
blindingFactor curves.Scalar
|
|||
|
|
rSigma curves.Scalar
|
|||
|
|
rRho curves.Scalar
|
|||
|
|
rDeltaSigma curves.Scalar
|
|||
|
|
rDeltaRho curves.Scalar
|
|||
|
|
sigma curves.Scalar
|
|||
|
|
rho curves.Scalar
|
|||
|
|
capRSigma curves.Point
|
|||
|
|
capRRho curves.Point
|
|||
|
|
capRDeltaSigma curves.Point
|
|||
|
|
capRDeltaRho curves.Point
|
|||
|
|
capRE curves.Scalar
|
|||
|
|
accumulator curves.Point
|
|||
|
|
witnessValue curves.Scalar
|
|||
|
|
xG1 curves.Point
|
|||
|
|
yG1 curves.Point
|
|||
|
|
zG1 curves.Point
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
// New initiates values of MembershipProofCommitting
|
|||
|
|
func (mpc *MembershipProofCommitting) New(
|
|||
|
|
witness *MembershipWitness,
|
|||
|
|
acc *Accumulator,
|
|||
|
|
pp *ProofParams,
|
|||
|
|
pk *PublicKey,
|
|||
|
|
) (*MembershipProofCommitting, error) {
|
|||
|
|
// Randomly select σ, ρ
|
|||
|
|
sigma := witness.y.Random(crand.Reader)
|
|||
|
|
rho := witness.y.Random(crand.Reader)
|
|||
|
|
|
|||
|
|
// E_C = C + (σ + ρ)Z
|
|||
|
|
t := sigma
|
|||
|
|
t = t.Add(rho)
|
|||
|
|
eC := pp.z
|
|||
|
|
eC = eC.Mul(t)
|
|||
|
|
eC = eC.Add(witness.c)
|
|||
|
|
|
|||
|
|
// T_σ = σX
|
|||
|
|
tSigma := pp.x
|
|||
|
|
tSigma = tSigma.Mul(sigma)
|
|||
|
|
|
|||
|
|
// T_ρ = ρY
|
|||
|
|
tRho := pp.y
|
|||
|
|
tRho = tRho.Mul(rho)
|
|||
|
|
|
|||
|
|
// δ_σ = yσ
|
|||
|
|
deltaSigma := witness.y
|
|||
|
|
deltaSigma = deltaSigma.Mul(sigma)
|
|||
|
|
|
|||
|
|
// δ_ρ = yρ
|
|||
|
|
deltaRho := witness.y
|
|||
|
|
deltaRho = deltaRho.Mul(rho)
|
|||
|
|
|
|||
|
|
// Randomly pick r_σ,r_ρ,r_δσ,r_δρ
|
|||
|
|
rY := witness.y.Random(crand.Reader)
|
|||
|
|
rSigma := witness.y.Random(crand.Reader)
|
|||
|
|
rRho := witness.y.Random(crand.Reader)
|
|||
|
|
rDeltaSigma := witness.y.Random(crand.Reader)
|
|||
|
|
rDeltaRho := witness.y.Random(crand.Reader)
|
|||
|
|
|
|||
|
|
// R_σ = r_σ X
|
|||
|
|
capRSigma := pp.x
|
|||
|
|
capRSigma = capRSigma.Mul(rSigma)
|
|||
|
|
|
|||
|
|
// R_ρ = ρY
|
|||
|
|
capRRho := pp.y
|
|||
|
|
capRRho = capRRho.Mul(rRho)
|
|||
|
|
|
|||
|
|
// R_δσ = r_y T_σ - r_δσ X
|
|||
|
|
negX := pp.x
|
|||
|
|
negX = negX.Neg()
|
|||
|
|
capRDeltaSigma := tSigma.Mul(rY)
|
|||
|
|
capRDeltaSigma = capRDeltaSigma.Add(negX.Mul(rDeltaSigma))
|
|||
|
|
|
|||
|
|
// R_δρ = r_y T_ρ - r_δρ Y
|
|||
|
|
negY := pp.y
|
|||
|
|
negY = negY.Neg()
|
|||
|
|
capRDeltaRho := tRho.Mul(rY)
|
|||
|
|
capRDeltaRho = capRDeltaRho.Add(negY.Mul(rDeltaRho))
|
|||
|
|
|
|||
|
|
// P~
|
|||
|
|
g2 := pk.value.Generator()
|
|||
|
|
|
|||
|
|
// -r_δσ - r_δρ
|
|||
|
|
exp := rDeltaSigma
|
|||
|
|
exp = exp.Add(rDeltaRho)
|
|||
|
|
exp = exp.Neg()
|
|||
|
|
|
|||
|
|
// -r_σ - r_ρ
|
|||
|
|
exp2 := rSigma
|
|||
|
|
exp2 = exp2.Add(rRho)
|
|||
|
|
exp2 = exp2.Neg()
|
|||
|
|
|
|||
|
|
// rY * eC
|
|||
|
|
rYeC := eC.Mul(rY)
|
|||
|
|
|
|||
|
|
// (-r_δσ - r_δρ)*Z
|
|||
|
|
expZ := pp.z.Mul(exp)
|
|||
|
|
|
|||
|
|
// (-r_σ - r_ρ)*Z
|
|||
|
|
exp2Z := pp.z.Mul(exp2)
|
|||
|
|
|
|||
|
|
// Prepare
|
|||
|
|
rYeCPrep, ok := rYeC.(curves.PairingPoint)
|
|||
|
|
if !ok {
|
|||
|
|
return nil, errors.New("incorrect type conversion")
|
|||
|
|
}
|
|||
|
|
g2Prep, ok := g2.(curves.PairingPoint)
|
|||
|
|
if !ok {
|
|||
|
|
return nil, errors.New("incorrect type conversion")
|
|||
|
|
}
|
|||
|
|
expZPrep, ok := expZ.(curves.PairingPoint)
|
|||
|
|
if !ok {
|
|||
|
|
return nil, errors.New("incorrect type conversion")
|
|||
|
|
}
|
|||
|
|
exp2ZPrep, ok := exp2Z.(curves.PairingPoint)
|
|||
|
|
if !ok {
|
|||
|
|
return nil, errors.New("incorrect type conversion")
|
|||
|
|
}
|
|||
|
|
pkPrep := pk.value
|
|||
|
|
|
|||
|
|
// Pairing
|
|||
|
|
capRE := g2Prep.MultiPairing(rYeCPrep, g2Prep, expZPrep, g2Prep, exp2ZPrep, pkPrep)
|
|||
|
|
|
|||
|
|
return &MembershipProofCommitting{
|
|||
|
|
eC,
|
|||
|
|
tSigma,
|
|||
|
|
tRho,
|
|||
|
|
deltaSigma,
|
|||
|
|
deltaRho,
|
|||
|
|
rY,
|
|||
|
|
rSigma,
|
|||
|
|
rRho,
|
|||
|
|
rDeltaSigma,
|
|||
|
|
rDeltaRho,
|
|||
|
|
sigma,
|
|||
|
|
rho,
|
|||
|
|
capRSigma,
|
|||
|
|
capRRho,
|
|||
|
|
capRDeltaSigma,
|
|||
|
|
capRDeltaRho,
|
|||
|
|
capRE,
|
|||
|
|
acc.value,
|
|||
|
|
witness.y,
|
|||
|
|
pp.x,
|
|||
|
|
pp.y,
|
|||
|
|
pp.z,
|
|||
|
|
}, nil
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
// GetChallenge returns bytes that need to be hashed for generating challenge.
|
|||
|
|
// V || Ec || T_sigma || T_rho || R_E || R_sigma || R_rho || R_delta_sigma || R_delta_rho
|
|||
|
|
func (mpc MembershipProofCommitting) GetChallengeBytes() []byte {
|
|||
|
|
res := mpc.accumulator.ToAffineCompressed()
|
|||
|
|
res = append(res, mpc.eC.ToAffineCompressed()...)
|
|||
|
|
res = append(res, mpc.tSigma.ToAffineCompressed()...)
|
|||
|
|
res = append(res, mpc.tRho.ToAffineCompressed()...)
|
|||
|
|
res = append(res, mpc.capRE.Bytes()...)
|
|||
|
|
res = append(res, mpc.capRSigma.ToAffineCompressed()...)
|
|||
|
|
res = append(res, mpc.capRRho.ToAffineCompressed()...)
|
|||
|
|
res = append(res, mpc.capRDeltaSigma.ToAffineCompressed()...)
|
|||
|
|
res = append(res, mpc.capRDeltaRho.ToAffineCompressed()...)
|
|||
|
|
return res
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
// GenProof computes the s values for Fiat-Shamir and return the actual
|
|||
|
|
// proof to be sent to the verifier given the challenge c.
|
|||
|
|
func (mpc *MembershipProofCommitting) GenProof(c curves.Scalar) *MembershipProof {
|
|||
|
|
// s_y = r_y + c*y
|
|||
|
|
sY := schnorr(mpc.blindingFactor, mpc.witnessValue, c)
|
|||
|
|
// s_σ = r_σ + c*σ
|
|||
|
|
sSigma := schnorr(mpc.rSigma, mpc.sigma, c)
|
|||
|
|
// s_ρ = r_ρ + c*ρ
|
|||
|
|
sRho := schnorr(mpc.rRho, mpc.rho, c)
|
|||
|
|
// s_δσ = rδσ + c*δ_σ
|
|||
|
|
sDeltaSigma := schnorr(mpc.rDeltaSigma, mpc.deltaSigma, c)
|
|||
|
|
// s_δρ = rδρ + c*δ_ρ
|
|||
|
|
sDeltaRho := schnorr(mpc.rDeltaRho, mpc.deltaRho, c)
|
|||
|
|
|
|||
|
|
return &MembershipProof{
|
|||
|
|
mpc.eC,
|
|||
|
|
mpc.tSigma,
|
|||
|
|
mpc.tRho,
|
|||
|
|
sSigma,
|
|||
|
|
sRho,
|
|||
|
|
sDeltaSigma,
|
|||
|
|
sDeltaRho,
|
|||
|
|
sY,
|
|||
|
|
}
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
func schnorr(r, v, challenge curves.Scalar) curves.Scalar {
|
|||
|
|
res := v
|
|||
|
|
res = res.Mul(challenge)
|
|||
|
|
res = res.Add(r)
|
|||
|
|
return res
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
type membershipProofMarshal struct {
|
|||
|
|
EC []byte `bare:"e_c"`
|
|||
|
|
TSigma []byte `bare:"t_sigma"`
|
|||
|
|
TRho []byte `bare:"t_rho"`
|
|||
|
|
SSigma []byte `bare:"s_sigma"`
|
|||
|
|
SRho []byte `bare:"s_rho"`
|
|||
|
|
SDeltaSigma []byte `bare:"s_delta_sigma"`
|
|||
|
|
SDeltaRho []byte `bare:"s_delta_rho"`
|
|||
|
|
SY []byte `bare:"s_y"`
|
|||
|
|
Curve string `bare:"curve"`
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
// MembershipProof contains values in the proof to be verified
|
|||
|
|
type MembershipProof struct {
|
|||
|
|
eC curves.Point
|
|||
|
|
tSigma curves.Point
|
|||
|
|
tRho curves.Point
|
|||
|
|
sSigma curves.Scalar
|
|||
|
|
sRho curves.Scalar
|
|||
|
|
sDeltaSigma curves.Scalar
|
|||
|
|
sDeltaRho curves.Scalar
|
|||
|
|
sY curves.Scalar
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
// Finalize computes values in the proof to be verified.
|
|||
|
|
func (mp *MembershipProof) Finalize(acc *Accumulator, pp *ProofParams, pk *PublicKey, challenge curves.Scalar) (*MembershipProofFinal, error) {
|
|||
|
|
// R_σ = s_δ X + c T_σ
|
|||
|
|
negTSigma := mp.tSigma
|
|||
|
|
negTSigma = negTSigma.Neg()
|
|||
|
|
capRSigma := pp.x.Mul(mp.sSigma)
|
|||
|
|
capRSigma = capRSigma.Add(negTSigma.Mul(challenge))
|
|||
|
|
|
|||
|
|
// R_ρ = s_ρ Y + c T_ρ
|
|||
|
|
negTRho := mp.tRho
|
|||
|
|
negTRho = negTRho.Neg()
|
|||
|
|
capRRho := pp.y.Mul(mp.sRho)
|
|||
|
|
capRRho = capRRho.Add(negTRho.Mul(challenge))
|
|||
|
|
|
|||
|
|
// R_δσ = s_y T_σ - s_δσ X
|
|||
|
|
negX := pp.x
|
|||
|
|
negX = negX.Neg()
|
|||
|
|
capRDeltaSigma := mp.tSigma.Mul(mp.sY)
|
|||
|
|
capRDeltaSigma = capRDeltaSigma.Add(negX.Mul(mp.sDeltaSigma))
|
|||
|
|
|
|||
|
|
// R_δρ = s_y T_ρ - s_δρ Y
|
|||
|
|
negY := pp.y
|
|||
|
|
negY = negY.Neg()
|
|||
|
|
capRDeltaRho := mp.tRho.Mul(mp.sY)
|
|||
|
|
capRDeltaRho = capRDeltaRho.Add(negY.Mul(mp.sDeltaRho))
|
|||
|
|
|
|||
|
|
// tildeP
|
|||
|
|
g2 := pk.value.Generator()
|
|||
|
|
|
|||
|
|
// Compute capRE, the pairing
|
|||
|
|
// E_c * s_y
|
|||
|
|
eCsY := mp.eC.Mul(mp.sY)
|
|||
|
|
|
|||
|
|
// (-s_delta_sigma - s_delta_rho) * Z
|
|||
|
|
exp := mp.sDeltaSigma
|
|||
|
|
exp = exp.Add(mp.sDeltaRho)
|
|||
|
|
exp = exp.Neg()
|
|||
|
|
expZ := pp.z.Mul(exp)
|
|||
|
|
|
|||
|
|
// (-c) * V
|
|||
|
|
exp = challenge.Neg()
|
|||
|
|
expV := acc.value.Mul(exp)
|
|||
|
|
|
|||
|
|
// E_c * s_y + (-s_delta_sigma - s_delta_rho) * Z + (-c) * V
|
|||
|
|
lhs := eCsY.Add(expZ).Add(expV)
|
|||
|
|
|
|||
|
|
// (-s_sigma - s_rho) * Z
|
|||
|
|
exp = mp.sSigma
|
|||
|
|
exp = exp.Add(mp.sRho)
|
|||
|
|
exp = exp.Neg()
|
|||
|
|
expZ2 := pp.z.Mul(exp)
|
|||
|
|
|
|||
|
|
// E_c * c
|
|||
|
|
cEc := mp.eC.Mul(challenge)
|
|||
|
|
|
|||
|
|
// (-s_sigma - s_rho) * Z + E_c * c
|
|||
|
|
rhs := cEc.Add(expZ2)
|
|||
|
|
|
|||
|
|
// Prepare
|
|||
|
|
lhsPrep, ok := lhs.(curves.PairingPoint)
|
|||
|
|
if !ok {
|
|||
|
|
return nil, errors.New("incorrect type conversion")
|
|||
|
|
}
|
|||
|
|
g2Prep, ok := g2.(curves.PairingPoint)
|
|||
|
|
if !ok {
|
|||
|
|
return nil, errors.New("incorrect type conversion")
|
|||
|
|
}
|
|||
|
|
rhsPrep, ok := rhs.(curves.PairingPoint)
|
|||
|
|
if !ok {
|
|||
|
|
return nil, errors.New("incorrect type conversion")
|
|||
|
|
}
|
|||
|
|
pkPrep := pk.value
|
|||
|
|
|
|||
|
|
// capRE
|
|||
|
|
capRE := g2Prep.MultiPairing(lhsPrep, g2Prep, rhsPrep, pkPrep)
|
|||
|
|
|
|||
|
|
return &MembershipProofFinal{
|
|||
|
|
acc.value,
|
|||
|
|
mp.eC,
|
|||
|
|
mp.tSigma,
|
|||
|
|
mp.tRho,
|
|||
|
|
capRE,
|
|||
|
|
capRSigma,
|
|||
|
|
capRRho,
|
|||
|
|
capRDeltaSigma,
|
|||
|
|
capRDeltaRho,
|
|||
|
|
}, nil
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
// MarshalBinary converts MembershipProof to bytes
|
|||
|
|
func (mp MembershipProof) MarshalBinary() ([]byte, error) {
|
|||
|
|
tv := &membershipProofMarshal{
|
|||
|
|
EC: mp.eC.ToAffineCompressed(),
|
|||
|
|
TSigma: mp.tSigma.ToAffineCompressed(),
|
|||
|
|
TRho: mp.tRho.ToAffineCompressed(),
|
|||
|
|
SSigma: mp.sSigma.Bytes(),
|
|||
|
|
SRho: mp.sRho.Bytes(),
|
|||
|
|
SDeltaSigma: mp.sDeltaSigma.Bytes(),
|
|||
|
|
SDeltaRho: mp.sDeltaRho.Bytes(),
|
|||
|
|
SY: mp.sY.Bytes(),
|
|||
|
|
Curve: mp.eC.CurveName(),
|
|||
|
|
}
|
|||
|
|
return bare.Marshal(tv)
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
// UnmarshalBinary converts bytes to MembershipProof
|
|||
|
|
func (mp *MembershipProof) UnmarshalBinary(data []byte) error {
|
|||
|
|
if data == nil {
|
|||
|
|
return fmt.Errorf("expected non-zero byte sequence")
|
|||
|
|
}
|
|||
|
|
tv := new(membershipProofMarshal)
|
|||
|
|
err := bare.Unmarshal(data, tv)
|
|||
|
|
if err != nil {
|
|||
|
|
return err
|
|||
|
|
}
|
|||
|
|
curve := curves.GetCurveByName(tv.Curve)
|
|||
|
|
if curve == nil {
|
|||
|
|
return fmt.Errorf("invalid curve")
|
|||
|
|
}
|
|||
|
|
eC, err := curve.NewIdentityPoint().FromAffineCompressed(tv.EC)
|
|||
|
|
if err != nil {
|
|||
|
|
return err
|
|||
|
|
}
|
|||
|
|
tSigma, err := curve.NewIdentityPoint().FromAffineCompressed(tv.TSigma)
|
|||
|
|
if err != nil {
|
|||
|
|
return err
|
|||
|
|
}
|
|||
|
|
tRho, err := curve.NewIdentityPoint().FromAffineCompressed(tv.TRho)
|
|||
|
|
if err != nil {
|
|||
|
|
return err
|
|||
|
|
}
|
|||
|
|
sSigma, err := curve.NewScalar().SetBytes(tv.SSigma)
|
|||
|
|
if err != nil {
|
|||
|
|
return err
|
|||
|
|
}
|
|||
|
|
sRho, err := curve.NewScalar().SetBytes(tv.SRho)
|
|||
|
|
if err != nil {
|
|||
|
|
return err
|
|||
|
|
}
|
|||
|
|
sDeltaSigma, err := curve.NewScalar().SetBytes(tv.SDeltaSigma)
|
|||
|
|
if err != nil {
|
|||
|
|
return err
|
|||
|
|
}
|
|||
|
|
sDeltaRho, err := curve.NewScalar().SetBytes(tv.SDeltaRho)
|
|||
|
|
if err != nil {
|
|||
|
|
return err
|
|||
|
|
}
|
|||
|
|
sY, err := curve.NewScalar().SetBytes(tv.SY)
|
|||
|
|
if err != nil {
|
|||
|
|
return err
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
mp.eC = eC
|
|||
|
|
mp.tSigma = tSigma
|
|||
|
|
mp.tRho = tRho
|
|||
|
|
mp.sSigma = sSigma
|
|||
|
|
mp.sRho = sRho
|
|||
|
|
mp.sDeltaSigma = sDeltaSigma
|
|||
|
|
mp.sDeltaRho = sDeltaRho
|
|||
|
|
mp.sY = sY
|
|||
|
|
|
|||
|
|
return nil
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
// MembershipProofFinal contains values that are input to Fiat-Shamir Heuristic
|
|||
|
|
type MembershipProofFinal struct {
|
|||
|
|
accumulator curves.Point
|
|||
|
|
eC curves.Point
|
|||
|
|
tSigma curves.Point
|
|||
|
|
tRho curves.Point
|
|||
|
|
capRE curves.Scalar
|
|||
|
|
capRSigma curves.Point
|
|||
|
|
capRRho curves.Point
|
|||
|
|
capRDeltaSigma curves.Point
|
|||
|
|
capRDeltaRho curves.Point
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
// GetChallenge computes Fiat-Shamir Heuristic taking input values of MembershipProofFinal
|
|||
|
|
func (m MembershipProofFinal) GetChallenge(curve *curves.PairingCurve) curves.Scalar {
|
|||
|
|
res := m.accumulator.ToAffineCompressed()
|
|||
|
|
res = append(res, m.eC.ToAffineCompressed()...)
|
|||
|
|
res = append(res, m.tSigma.ToAffineCompressed()...)
|
|||
|
|
res = append(res, m.tRho.ToAffineCompressed()...)
|
|||
|
|
res = append(res, m.capRE.Bytes()...)
|
|||
|
|
res = append(res, m.capRSigma.ToAffineCompressed()...)
|
|||
|
|
res = append(res, m.capRRho.ToAffineCompressed()...)
|
|||
|
|
res = append(res, m.capRDeltaSigma.ToAffineCompressed()...)
|
|||
|
|
res = append(res, m.capRDeltaRho.ToAffineCompressed()...)
|
|||
|
|
challenge := curve.Scalar.Hash(res)
|
|||
|
|
return challenge
|
|||
|
|
}
|