yaole
107 lines
1.9 KiB
Go
107 lines
1.9 KiB
Go
package dkgc
|
|
|
|
import (
|
|
"crypto/rand"
|
|
"io"
|
|
"math/big"
|
|
|
|
"xdx.jelly/xgcl/sm/sm9"
|
|
)
|
|
|
|
type ServerKey struct {
|
|
big.Int
|
|
}
|
|
|
|
type ClientKey = sm9.UserSignKey
|
|
|
|
func ServerGenerateKey(r io.Reader) (sk *ServerKey, basePoint *ClientKey, err error) {
|
|
for {
|
|
x, err := rand.Int(r, sm9.Order())
|
|
if err != nil {
|
|
return nil, nil, err
|
|
}
|
|
if x.Sign() == 0 {
|
|
continue
|
|
}
|
|
sk = &ServerKey{
|
|
Int: *x,
|
|
}
|
|
basePoint = &ClientKey{}
|
|
y := new(big.Int).Set(x)
|
|
y.ModInverse(y, sm9.Order())
|
|
basePoint.G1.ScalarBaseMult(y)
|
|
return sk, basePoint, nil
|
|
}
|
|
}
|
|
|
|
type ClientSignContext struct {
|
|
r1 big.Int
|
|
}
|
|
|
|
func (csc *ClientSignContext) ComputeSignData(r io.Reader, pubs *sm9.MastSignPublicKey) (u *sm9.GT, err error) {
|
|
for {
|
|
x, err := rand.Int(r, sm9.Order())
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
if x.Sign() == 0 {
|
|
continue
|
|
}
|
|
csc.r1 = *x
|
|
break
|
|
}
|
|
u = sm9.Pairing(sm9.G1Generator(), &pubs.G2)
|
|
u.ScalarMult(u, &csc.r1)
|
|
return u, nil
|
|
}
|
|
|
|
func (csc *ClientSignContext) ComputeSignature(id []byte, h, k1, k2 *big.Int, kc *ClientKey) (*sm9.Signature, error) {
|
|
sig := &sm9.Signature{}
|
|
sig.H = *h
|
|
x := new(big.Int)
|
|
x.Mul(&csc.r1, k1)
|
|
x.Add(x, k2)
|
|
sig.S.ScalarMult(&kc.G1, x)
|
|
return sig, nil
|
|
}
|
|
|
|
func ServerComputeSignData(r io.Reader, u *sm9.GT, m []byte, pubs *sm9.MastSignPublicKey, ks *ServerKey) (h, k1, k2 *big.Int, err error) {
|
|
r2 := new(big.Int)
|
|
r3 := new(big.Int)
|
|
for {
|
|
r2, err = rand.Int(r, sm9.Order())
|
|
if err != nil {
|
|
return nil, nil, nil, err
|
|
}
|
|
if r2.Sign() == 0 {
|
|
continue
|
|
}
|
|
break
|
|
}
|
|
|
|
for {
|
|
r3, err = rand.Int(r, sm9.Order())
|
|
if err != nil {
|
|
return nil, nil, nil, err
|
|
}
|
|
if r3.Sign() == 0 {
|
|
continue
|
|
}
|
|
break
|
|
}
|
|
|
|
g := sm9.Pairing(sm9.G1Generator(), &pubs.G2)
|
|
g.ScalarMult(g, r3)
|
|
w := new(sm9.GT)
|
|
w.ScalarMult(u, r2)
|
|
w.Add(w, g)
|
|
h = sm9.H2(m, w.Marshal())
|
|
|
|
k1 = new(big.Int).Mul(r2, &ks.Int)
|
|
k1.Mod(k1, sm9.Order())
|
|
k2 = new(big.Int).Sub(r3, h)
|
|
k2.Mul(k2, &ks.Int)
|
|
k2.Mod(k2, sm9.Order())
|
|
return h, k1, k2, nil
|
|
}
|