// ProposeVote calls the 'accept'-vote on the current propose-configuration func (i *Identity) ProposeVote(accept bool) onet.ClientError { log.Lvl3("Voting proposal") if i.Proposed == nil { return onet.NewClientErrorCode(ErrorConfigMissing, "No proposed config") } log.Lvlf3("Voting %t on %s", accept, i.Proposed.Device) if !accept { return nil } hash, err := i.Proposed.Hash() if err != nil { return onet.NewClientErrorCode(ErrorOnet, err.Error()) } sig, err := crypto.SignSchnorr(network.Suite, i.Private, hash) if err != nil { return onet.NewClientErrorCode(ErrorOnet, err.Error()) } pvr := &ProposeVoteReply{} cerr := i.Client.SendProtobuf(i.Cothority.RandomServerIdentity(), &ProposeVote{ ID: i.ID, Signer: i.DeviceName, Signature: &sig, }, pvr) if cerr != nil { return cerr } if pvr.Data != nil { log.Lvl2("Threshold reached and signed") i.Config = i.Proposed i.Proposed = nil } else { log.Lvl2("Threshold not reached") } return nil }
// HandleSignRequest is a handler for incoming sign-requests. It's registered as // a handler in the onet.Node. func (p *Protocol) HandleSignRequest(msg structMessage) error { p.Message = msg.Msg p.verifySignature = msg.VerifySignature signature, err := crypto.SignSchnorr(network.Suite, p.Private(), p.Message) if err != nil { return err } // fill our own signature p.signature = &SignatureReply{ Sig: signature, Index: p.TreeNode().RosterIndex} if !p.IsLeaf() { for _, c := range p.Children() { err := p.SendTo(c, &msg.Message) if err != nil { return err } } } else { err := p.SendTo(p.Parent(), &SignatureBundle{ChildSig: p.signature}) p.Done() return err } return nil }
// computeBlockSignature compute the signature out of the block. func (nt *Ntree) computeBlockSignature() { // wait the end of verification of the block ok := <-nt.verifyBlockChan //marshal the blck marshalled, err := json.Marshal(nt.block) if err != nil { log.Error(err) return } // if stg is wrong, we put exceptions if !ok { nt.tempBlockSig.Exceptions = append(nt.tempBlockSig.Exceptions, Exception{nt.TreeNode().ID}) } else { // we put signature schnorr, _ := crypto.SignSchnorr(nt.Suite(), nt.Private(), marshalled) nt.tempBlockSig.Sigs = append(nt.tempBlockSig.Sigs, schnorr) } log.Lvl3(nt.Name(), "Block Signature Computed") }
// computeSignatureResponse will compute the response out of the signature // request. It's the final signature. func (nt *Ntree) computeSignatureResponse() { // wait for the verification to be done ok := <-nt.verifySignatureRequestChan if !ok { nt.tempSignatureResponse.Exceptions = append(nt.tempSignatureResponse.Exceptions, Exception{nt.TreeNode().ID}) } else { // compute the message out of the previous signature // marshal only the header here (so signature between the two phases are // garanteed to be different) marshalled, err := json.Marshal(nt.block.Header) if err != nil { log.Error(err) return } sig, err := crypto.SignSchnorr(nt.Suite(), nt.Private(), marshalled) if err != nil { return } nt.tempSignatureResponse.Sigs = append(nt.tempSignatureResponse.Sigs, sig) } }
func signSchnorr(suite abstract.Suite, key abstract.Scalar, m interface{}) error { // Reset signature field reflect.ValueOf(m).Elem().FieldByName("Sig").Set(reflect.ValueOf(crypto.SchnorrSig{})) // XXX: hack // Marshal message mb, err := network.MarshalRegisteredType(m) if err != nil { return err } // Sign message sig, err := crypto.SignSchnorr(suite, key, mb) if err != nil { return err } // Store signature reflect.ValueOf(m).Elem().FieldByName("Sig").Set(reflect.ValueOf(sig)) // XXX: hack return nil }