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/ot/base/simplest" "source.quilibrium.com/quilibrium/monorepo/nekryptology/pkg/tecdsa/dkls/v1/dkg" "source.quilibrium.com/quilibrium/monorepo/nekryptology/pkg/tecdsa/dkls/v1/refresh" ) func newRefreshProtocolMessage(payload []byte, round string, version uint) *protocol.Message { return &protocol.Message{ Protocol: protocol.Dkls18Refresh, Version: version, Payloads: map[string][]byte{payloadKey: payload}, Metadata: map[string]string{"round": round}, } } func versionIsSupported(messageVersion uint) error { if messageVersion < uint(protocol.Version1) { return errors.New("only version 1 is supported.") } return nil } func encodeRefreshRound1Output(seed curves.Scalar, version uint) (*protocol.Message, error) { if err := versionIsSupported(version); err != nil { return nil, errors.Wrap(err, "version error") } registerTypes() buf := bytes.NewBuffer([]byte{}) enc := gob.NewEncoder(buf) if err := enc.Encode(&seed); err != nil { return nil, errors.WithStack(err) } return newRefreshProtocolMessage(buf.Bytes(), "1", version), nil } func decodeRefreshRound2Input(m *protocol.Message) (curves.Scalar, error) { if err := versionIsSupported(m.Version); err != nil { return nil, errors.Wrap(err, "version error") } buf := bytes.NewBuffer(m.Payloads[payloadKey]) dec := gob.NewDecoder(buf) decoded := new(curves.Scalar) if err := dec.Decode(&decoded); err != nil { return nil, errors.WithStack(err) } return *decoded, nil } func encodeRefreshRound2Output(output *refresh.RefreshRound2Output, version uint) (*protocol.Message, error) { if err := versionIsSupported(version); err != nil { return nil, errors.Wrap(err, "version error") } buf := bytes.NewBuffer([]byte{}) enc := gob.NewEncoder(buf) if err := enc.Encode(output); err != nil { return nil, errors.WithStack(err) } return newRefreshProtocolMessage(buf.Bytes(), "2", version), nil } func decodeRefreshRound3Input(m *protocol.Message) (*refresh.RefreshRound2Output, error) { if err := versionIsSupported(m.Version); err != nil { return nil, errors.Wrap(err, "version error") } buf := bytes.NewBuffer(m.Payloads[payloadKey]) dec := gob.NewDecoder(buf) decoded := new(refresh.RefreshRound2Output) if err := dec.Decode(decoded); err != nil { return nil, errors.WithStack(err) } return decoded, nil } func encodeRefreshRound3Output(choices []simplest.ReceiversMaskedChoices, version uint) (*protocol.Message, error) { if err := versionIsSupported(version); err != nil { return nil, errors.Wrap(err, "version error") } buf := bytes.NewBuffer([]byte{}) enc := gob.NewEncoder(buf) if err := enc.Encode(choices); err != nil { return nil, errors.WithStack(err) } return newRefreshProtocolMessage(buf.Bytes(), "3", version), nil } func decodeRefreshRound4Input(m *protocol.Message) ([]simplest.ReceiversMaskedChoices, error) { if err := versionIsSupported(m.Version); err != nil { return nil, errors.Wrap(err, "version error") } buf := bytes.NewBuffer(m.Payloads[payloadKey]) dec := gob.NewDecoder(buf) decoded := []simplest.ReceiversMaskedChoices{} if err := dec.Decode(&decoded); err != nil { return nil, errors.WithStack(err) } return decoded, nil } func encodeRefreshRound4Output(challenge []simplest.OtChallenge, version uint) (*protocol.Message, error) { if err := versionIsSupported(version); err != nil { return nil, errors.Wrap(err, "version error") } buf := bytes.NewBuffer([]byte{}) enc := gob.NewEncoder(buf) if err := enc.Encode(challenge); err != nil { return nil, errors.WithStack(err) } return newRefreshProtocolMessage(buf.Bytes(), "4", version), nil } func decodeRefreshRound5Input(m *protocol.Message) ([]simplest.OtChallenge, error) { if err := versionIsSupported(m.Version); err != nil { return nil, errors.Wrap(err, "version error") } buf := bytes.NewBuffer(m.Payloads[payloadKey]) dec := gob.NewDecoder(buf) decoded := []simplest.OtChallenge{} if err := dec.Decode(&decoded); err != nil { return nil, errors.WithStack(err) } return decoded, nil } func encodeRefreshRound5Output(responses []simplest.OtChallengeResponse, version uint) (*protocol.Message, error) { if err := versionIsSupported(version); err != nil { return nil, errors.Wrap(err, "version error") } buf := bytes.NewBuffer([]byte{}) enc := gob.NewEncoder(buf) if err := enc.Encode(responses); err != nil { return nil, errors.WithStack(err) } return newRefreshProtocolMessage(buf.Bytes(), "5", version), nil } func decodeRefreshRound6Input(m *protocol.Message) ([]simplest.OtChallengeResponse, error) { if err := versionIsSupported(m.Version); err != nil { return nil, errors.Wrap(err, "version error") } buf := bytes.NewBuffer(m.Payloads[payloadKey]) dec := gob.NewDecoder(buf) decoded := []simplest.OtChallengeResponse{} if err := dec.Decode(&decoded); err != nil { return nil, errors.WithStack(err) } return decoded, nil } func encodeRefreshRound6Output(opening []simplest.ChallengeOpening, version uint) (*protocol.Message, error) { if err := versionIsSupported(version); err != nil { return nil, errors.Wrap(err, "version error") } buf := bytes.NewBuffer([]byte{}) enc := gob.NewEncoder(buf) if err := enc.Encode(opening); err != nil { return nil, errors.WithStack(err) } return newRefreshProtocolMessage(buf.Bytes(), "6", version), nil } func decodeRefreshRound7Input(m *protocol.Message) ([]simplest.ChallengeOpening, error) { if err := versionIsSupported(m.Version); err != nil { return nil, errors.Wrap(err, "version error") } buf := bytes.NewBuffer(m.Payloads[payloadKey]) dec := gob.NewDecoder(buf) decoded := []simplest.ChallengeOpening{} if err := dec.Decode(&decoded); err != nil { return nil, errors.WithStack(err) } return decoded, nil } // EncodeAliceRefreshOutput serializes Alice Refresh output based on the protocol version. func EncodeAliceRefreshOutput(result *dkg.AliceOutput, version uint) (*protocol.Message, error) { if err := versionIsSupported(version); err != nil { return nil, errors.Wrap(err, "version error") } registerTypes() buf := bytes.NewBuffer([]byte{}) enc := gob.NewEncoder(buf) if err := enc.Encode(result); err != nil { return nil, errors.WithStack(err) } return newRefreshProtocolMessage(buf.Bytes(), "alice-output", version), nil } // DecodeAliceRefreshResult deserializes Alice refresh output. func DecodeAliceRefreshResult(m *protocol.Message) (*dkg.AliceOutput, error) { if err := versionIsSupported(m.Version); err != nil { return nil, errors.Wrap(err, "version error") } registerTypes() buf := bytes.NewBuffer(m.Payloads[payloadKey]) dec := gob.NewDecoder(buf) decoded := new(dkg.AliceOutput) if err := dec.Decode(&decoded); err != nil { return nil, errors.WithStack(err) } return decoded, nil } // EncodeBobRefreshOutput serializes Bob refresh output based on the protocol version. func EncodeBobRefreshOutput(result *dkg.BobOutput, version uint) (*protocol.Message, error) { if err := versionIsSupported(version); err != nil { return nil, errors.Wrap(err, "version error") } registerTypes() buf := bytes.NewBuffer([]byte{}) enc := gob.NewEncoder(buf) if err := enc.Encode(result); err != nil { return nil, errors.WithStack(err) } return newRefreshProtocolMessage(buf.Bytes(), "bob-output", version), nil } // DecodeBobRefreshResult deserializes Bob refhresh output. func DecodeBobRefreshResult(m *protocol.Message) (*dkg.BobOutput, error) { if err := versionIsSupported(m.Version); err != nil { return nil, errors.Wrap(err, "version error") } buf := bytes.NewBuffer(m.Payloads[payloadKey]) dec := gob.NewDecoder(buf) decoded := new(dkg.BobOutput) if err := dec.Decode(&decoded); err != nil { return nil, errors.WithStack(err) } return decoded, nil }