mirror of
https://github.com/tuneinsight/lattigo.git
synced 2025-09-13 03:27:14 +00:00
104 lines
3.2 KiB
Go
104 lines
3.2 KiB
Go
package multiparty
|
|
|
|
import (
|
|
"bufio"
|
|
"io"
|
|
|
|
"github.com/tuneinsight/lattigo/v6/core/rlwe"
|
|
"github.com/tuneinsight/lattigo/v6/utils/buffer"
|
|
)
|
|
|
|
// RefreshShare is a struct storing the decryption and recryption shares.
|
|
type RefreshShare struct {
|
|
EncToShareShare KeySwitchShare
|
|
ShareToEncShare KeySwitchShare
|
|
MetaData rlwe.MetaData
|
|
}
|
|
|
|
// BinarySize returns the serialized size of the object in bytes.
|
|
func (share RefreshShare) BinarySize() int {
|
|
return share.EncToShareShare.BinarySize() + share.ShareToEncShare.BinarySize() + share.MetaData.BinarySize()
|
|
}
|
|
|
|
// WriteTo writes the object on an [io.Writer]. It implements the [io.WriterTo]
|
|
// interface, and will write exactly object.BinarySize() bytes on w.
|
|
//
|
|
// Unless w implements the [buffer.Writer] interface (see lattigo/utils/buffer/writer.go),
|
|
// it will be wrapped into a [bufio.Writer]. Since this requires allocations, it
|
|
// is preferable to pass a [buffer.Writer] directly:
|
|
//
|
|
// - When writing multiple times to a [io.Writer], it is preferable to first wrap the
|
|
// [io.Writer] in a pre-allocated [bufio.Writer].
|
|
// - When writing to a pre-allocated var b []byte, it is preferable to pass
|
|
// buffer.NewBuffer(b) as w (see lattigo/utils/buffer/buffer.go).
|
|
func (share RefreshShare) WriteTo(w io.Writer) (n int64, err error) {
|
|
switch w := w.(type) {
|
|
case buffer.Writer:
|
|
|
|
if n, err = share.MetaData.WriteTo(w); err != nil {
|
|
return
|
|
}
|
|
|
|
var inc int64
|
|
if inc, err = share.EncToShareShare.WriteTo(w); err != nil {
|
|
return n + inc, err
|
|
}
|
|
|
|
n += inc
|
|
|
|
inc, err = share.ShareToEncShare.WriteTo(w)
|
|
|
|
return n + inc, err
|
|
default:
|
|
return share.WriteTo(bufio.NewWriter(w))
|
|
}
|
|
}
|
|
|
|
// ReadFrom reads on the object from an [io.Writer]. It implements the
|
|
// [io.ReaderFrom] interface.
|
|
//
|
|
// Unless r implements the [buffer.Reader] interface (see see lattigo/utils/buffer/reader.go),
|
|
// it will be wrapped into a [bufio.Reader]. Since this requires allocation, it
|
|
// is preferable to pass a [buffer.Reader] directly:
|
|
//
|
|
// - When reading multiple values from a [io.Reader], it is preferable to first
|
|
// first wrap [io.Reader] in a pre-allocated [bufio.Reader].
|
|
// - When reading from a var b []byte, it is preferable to pass a buffer.NewBuffer(b)
|
|
// as w (see lattigo/utils/buffer/buffer.go).
|
|
func (share *RefreshShare) ReadFrom(r io.Reader) (n int64, err error) {
|
|
switch r := r.(type) {
|
|
case buffer.Reader:
|
|
|
|
if n, err = share.MetaData.ReadFrom(r); err != nil {
|
|
return
|
|
}
|
|
|
|
var inc int64
|
|
if inc, err = share.EncToShareShare.ReadFrom(r); err != nil {
|
|
return
|
|
}
|
|
|
|
n += inc
|
|
|
|
inc, err = share.ShareToEncShare.ReadFrom(r)
|
|
|
|
return n + inc, err
|
|
default:
|
|
return share.ReadFrom(bufio.NewReader(r))
|
|
}
|
|
}
|
|
|
|
// MarshalBinary encodes the object into a binary form on a newly allocated slice of bytes.
|
|
func (share RefreshShare) MarshalBinary() (p []byte, err error) {
|
|
buf := buffer.NewBufferSize(share.BinarySize())
|
|
_, err = share.WriteTo(buf)
|
|
return buf.Bytes(), err
|
|
}
|
|
|
|
// UnmarshalBinary decodes a slice of bytes generated by
|
|
// [RefreshShare.MarshalBinary] or [RefreshShare.WriteTo] on the object.
|
|
func (share *RefreshShare) UnmarshalBinary(p []byte) (err error) {
|
|
_, err = share.ReadFrom(buffer.NewBuffer(p))
|
|
return
|
|
}
|