mirror of
https://source.quilibrium.com/quilibrium/ceremonyclient.git
synced 2024-12-26 16:45:18 +00:00
123 lines
3.7 KiB
Go
123 lines
3.7 KiB
Go
package v1
|
|
|
|
import (
|
|
"bytes"
|
|
"encoding/gob"
|
|
|
|
"github.com/pkg/errors"
|
|
|
|
"source.quilibrium.com/quilibrium/monorepo/nekryptology/pkg/core/curves"
|
|
"source.quilibrium.com/quilibrium/monorepo/nekryptology/pkg/core/protocol"
|
|
"source.quilibrium.com/quilibrium/monorepo/nekryptology/pkg/tecdsa/dkls/v1/sign"
|
|
)
|
|
|
|
func newSignProtocolMessage(payload []byte, round string, version uint) *protocol.Message {
|
|
return &protocol.Message{
|
|
Protocol: protocol.Dkls18Sign,
|
|
Version: version,
|
|
Payloads: map[string][]byte{payloadKey: payload},
|
|
Metadata: map[string]string{"round": round},
|
|
}
|
|
}
|
|
|
|
func encodeSignRound1Output(commitment [32]byte, version uint) (*protocol.Message, error) {
|
|
if version != protocol.Version1 {
|
|
return nil, errors.New("only version 1 is supported")
|
|
}
|
|
buf := bytes.NewBuffer([]byte{})
|
|
enc := gob.NewEncoder(buf)
|
|
if err := enc.Encode(&commitment); err != nil {
|
|
return nil, errors.WithStack(err)
|
|
}
|
|
return newSignProtocolMessage(buf.Bytes(), "1", version), nil
|
|
}
|
|
|
|
func decodeSignRound2Input(m *protocol.Message) ([32]byte, error) {
|
|
if m.Version != protocol.Version1 {
|
|
return [32]byte{}, errors.New("only version 1 is supported")
|
|
}
|
|
buf := bytes.NewBuffer(m.Payloads[payloadKey])
|
|
dec := gob.NewDecoder(buf)
|
|
decoded := [32]byte{}
|
|
if err := dec.Decode(&decoded); err != nil {
|
|
return [32]byte{}, errors.WithStack(err)
|
|
}
|
|
return decoded, nil
|
|
}
|
|
|
|
func encodeSignRound2Output(output *sign.SignRound2Output, version uint) (*protocol.Message, error) {
|
|
if version != protocol.Version1 {
|
|
return nil, errors.New("only version 1 is supported")
|
|
}
|
|
buf := bytes.NewBuffer([]byte{})
|
|
enc := gob.NewEncoder(buf)
|
|
if err := enc.Encode(output); err != nil {
|
|
return nil, errors.WithStack(err)
|
|
}
|
|
return newSignProtocolMessage(buf.Bytes(), "2", version), nil
|
|
}
|
|
|
|
func decodeSignRound3Input(m *protocol.Message) (*sign.SignRound2Output, error) {
|
|
if m.Version != protocol.Version1 {
|
|
return nil, errors.New("only version 1 is supported")
|
|
}
|
|
buf := bytes.NewBuffer(m.Payloads[payloadKey])
|
|
dec := gob.NewDecoder(buf)
|
|
decoded := &sign.SignRound2Output{}
|
|
if err := dec.Decode(&decoded); err != nil {
|
|
return nil, errors.WithStack(err)
|
|
}
|
|
return decoded, nil
|
|
}
|
|
|
|
func encodeSignRound3Output(output *sign.SignRound3Output, version uint) (*protocol.Message, error) {
|
|
if version != protocol.Version1 {
|
|
return nil, errors.New("only version 1 is supported")
|
|
}
|
|
buf := bytes.NewBuffer([]byte{})
|
|
enc := gob.NewEncoder(buf)
|
|
if err := enc.Encode(output); err != nil {
|
|
return nil, errors.WithStack(err)
|
|
}
|
|
return newSignProtocolMessage(buf.Bytes(), "3", version), nil
|
|
}
|
|
|
|
func decodeSignRound4Input(m *protocol.Message) (*sign.SignRound3Output, error) {
|
|
if m.Version != protocol.Version1 {
|
|
return nil, errors.New("only version 1 is supported")
|
|
}
|
|
buf := bytes.NewBuffer(m.Payloads[payloadKey])
|
|
dec := gob.NewDecoder(buf)
|
|
decoded := &sign.SignRound3Output{}
|
|
if err := dec.Decode(&decoded); err != nil {
|
|
return nil, errors.WithStack(err)
|
|
}
|
|
return decoded, nil
|
|
}
|
|
|
|
func encodeSignature(signature *curves.EcdsaSignature, version uint) (*protocol.Message, error) {
|
|
if version != protocol.Version1 {
|
|
return nil, errors.New("only version 1 is supported")
|
|
}
|
|
buf := bytes.NewBuffer([]byte{})
|
|
enc := gob.NewEncoder(buf)
|
|
if err := enc.Encode(signature); err != nil {
|
|
return nil, errors.WithStack(err)
|
|
}
|
|
return newSignProtocolMessage(buf.Bytes(), "signature", version), nil
|
|
}
|
|
|
|
// DecodeSignature serializes the signature.
|
|
func DecodeSignature(m *protocol.Message) (*curves.EcdsaSignature, error) {
|
|
if m.Version != protocol.Version1 {
|
|
return nil, errors.New("only version 1 is supported")
|
|
}
|
|
buf := bytes.NewBuffer(m.Payloads[payloadKey])
|
|
dec := gob.NewDecoder(buf)
|
|
decoded := &curves.EcdsaSignature{}
|
|
if err := dec.Decode(decoded); err != nil {
|
|
return nil, errors.WithStack(err)
|
|
}
|
|
return decoded, nil
|
|
}
|