drlwe

package
v3.0.5 Latest Latest
Warning

This package is not in the latest version of its module.

 Go to latest Published: Jun 13, 2022 License: Apache-2.0 Imports: 5 Imported by: 7

Documentation

Overview

Package drlwe implements a distributed (or threshold) version of the CKKS scheme that enables secure multiparty computation solutions with secret-shared secret keys.

Index

Constants

This section is empty.

Variables

This section is empty.

Functions

This section is empty.

Types

type CKGCRP 

type CKGCRP rlwe.PolyQP

CKGCRP is a type for common reference polynomials in the CKG protocol.

type CKGProtocol 

type CKGProtocol struct {
	// contains filtered or unexported fields
}

CKGProtocol is the structure storing the parameters and and precomputations for the collective key generation protocol.

func NewCKGProtocol 

func NewCKGProtocol(params rlwe.Parameters) *CKGProtocol

NewCKGProtocol creates a new CKGProtocol instance

func (*CKGProtocol) AggregateShare 

func (ckg *CKGProtocol) AggregateShare(share1, share2, shareOut *CKGShare)

AggregateShare aggregates a new share to the aggregate key

func (*CKGProtocol) AllocateShare 

func (ckg *CKGProtocol) AllocateShare() *CKGShare

AllocateShare allocates the share of the CKG protocol.

func (*CKGProtocol) GenPublicKey 

func (ckg *CKGProtocol) GenPublicKey(roundShare *CKGShare, crp CKGCRP, pubkey *rlwe.PublicKey)

GenPublicKey return the current aggregation of the received shares as a bfv.PublicKey.

func (*CKGProtocol) GenShare 

func (ckg *CKGProtocol) GenShare(sk *rlwe.SecretKey, crp CKGCRP, shareOut *CKGShare)

GenShare generates the party's public key share from its secret key as:

crp*s_i + e_i

for the receiver protocol. Has no effect is the share was already generated.

func (*CKGProtocol) SampleCRP 

func (ckg *CKGProtocol) SampleCRP(crs CRS) CKGCRP

SampleCRP samples a common random polynomial to be used in the CKG protocol from the provided common reference string.

func (*CKGProtocol) ShallowCopy 

func (ckg *CKGProtocol) ShallowCopy() *CKGProtocol

ShallowCopy creates a shallow copy of CKGProtocol in which all the read-only data-structures are shared with the receiver and the temporary buffers are reallocated. The receiver and the returned CKGProtocol can be used concurrently.

type CKGShare 

type CKGShare struct {
	Value rlwe.PolyQP
}

CKGShare is a struct storing the CKG protocol's share.

func (*CKGShare) MarshalBinary 

func (share *CKGShare) MarshalBinary() (data []byte, err error)

MarshalBinary encodes the target element on a slice of bytes.

func (*CKGShare) UnmarshalBinary 

func (share *CKGShare) UnmarshalBinary(data []byte) (err error)

UnmarshalBinary decodes a slice of bytes on the target element.

type CKSCRP 

type CKSCRP ring.Poly

CKSCRP is a type for common reference polynomials in the CKS protocol.

type CKSProtocol 

type CKSProtocol struct {
	// contains filtered or unexported fields
}

CKSProtocol is the structure storing the parameters and and precomputations for the collective key-switching protocol.

func NewCKSProtocol 

func NewCKSProtocol(params rlwe.Parameters, sigmaSmudging float64) *CKSProtocol

NewCKSProtocol creates a new CKSProtocol that will be used to perform a collective key-switching on a ciphertext encrypted under a collective public-key, whose secret-shares are distributed among j parties, re-encrypting the ciphertext under another public-key, whose secret-shares are also known to the parties.

func (*CKSProtocol) AggregateShare 

func (cks *CKSProtocol) AggregateShare(share1, share2, shareOut *CKSShare)

AggregateShare is the second part of the unique round of the CKSProtocol protocol. Upon receiving the j-1 elements each party computes :

[ctx[0] + sum((skInput_i - skOutput_i) * ctx[0] + e_i), ctx[1]]

func (*CKSProtocol) AllocateShare 

func (cks *CKSProtocol) AllocateShare(level int) *CKSShare

AllocateShare allocates the shares of the CKSProtocol

func (*CKSProtocol) GenShare 

func (cks *CKSProtocol) GenShare(skInput, skOutput *rlwe.SecretKey, c1 *ring.Poly, shareOut *CKSShare)

GenShare computes a party's share in the CKS protocol. ct1 is the degree 1 element of the rlwe.Ciphertext to keyswitch, i.e. ct1 = rlwe.Ciphertext.Value[1]. NTT flag for ct1 is expected to be set correctly.

func (*CKSProtocol) KeySwitch 

func (cks *CKSProtocol) KeySwitch(ctIn *rlwe.Ciphertext, combined *CKSShare, ctOut *rlwe.Ciphertext)

KeySwitch performs the actual keyswitching operation on a ciphertext ct and put the result in ctOut

func (*CKSProtocol) SampleCRP 

func (cks *CKSProtocol) SampleCRP(level int, crs CRS) CKSCRP

SampleCRP samples a common random polynomial to be used in the CKS protocol from the provided common reference string.

func (*CKSProtocol) ShallowCopy 

func (cks *CKSProtocol) ShallowCopy() *CKSProtocol

ShallowCopy creates a shallow copy of CKSProtocol in which all the read-only data-structures are shared with the receiver and the temporary buffers are reallocated. The receiver and the returned CKSProtocol can be used concurrently.

type CKSShare 

type CKSShare struct {
	Value *ring.Poly
}

CKSShare is a type for the CKS protocol shares.

func (*CKSShare) MarshalBinary 

func (ckss *CKSShare) MarshalBinary() (data []byte, err error)

MarshalBinary encodes a CKS share on a slice of bytes.

func (*CKSShare) UnmarshalBinary 

func (ckss *CKSShare) UnmarshalBinary(data []byte) (err error)

UnmarshalBinary decodes marshaled CKS share on the target CKS share.

type CRS 

type CRS interface {
	utils.PRNG
}

CRS is an interface for Common Reference Strings. CRSs are PRNGs for which the read bits are the same for all parties.

type CollectivePublicKeyGenerator 

type CollectivePublicKeyGenerator interface {
	AllocateShare() *CKGShare
	GenShare(sk *rlwe.SecretKey, crp CKGCRP, shareOut *CKGShare)
	AggregateShare(share1, share2, shareOut *CKGShare)
	GenPublicKey(aggregatedShare *CKGShare, crp CKGCRP, pubkey *rlwe.PublicKey)
}

CollectivePublicKeyGenerator is an interface describing the local steps of a generic RLWE CKG protocol.

type KeySwitchingProtocol 

type KeySwitchingProtocol interface {
	AllocateShare(level int) *CKSShare
	GenShare(skInput, skOutput *rlwe.SecretKey, c1 *ring.Poly, shareOut *CKSShare)
	AggregateShare(share1, share2, shareOut *CKSShare)
	KeySwitch(ctIn *rlwe.Ciphertext, combined *CKSShare, ctOut *rlwe.Ciphertext)
}

KeySwitchingProtocol is an interface describing the local steps of a generic RLWE CKS protocol

type PCKSProtocol 

type PCKSProtocol struct {
	// contains filtered or unexported fields
}

PCKSProtocol is the structure storing the parameters for the collective public key-switching.

func NewPCKSProtocol 

func NewPCKSProtocol(params rlwe.Parameters, sigmaSmudging float64) (pcks *PCKSProtocol)

NewPCKSProtocol creates a new PCKSProtocol object and will be used to re-encrypt a ciphertext ctx encrypted under a secret-shared key among j parties under a new collective public-key.

func (*PCKSProtocol) AggregateShare 

func (pcks *PCKSProtocol) AggregateShare(share1, share2, shareOut *PCKSShare)

AggregateShare is the second part of the first and unique round of the PCKSProtocol protocol. Each party uppon receiving the j-1 elements from the other parties computes :

[ctx[0] + sum(s_i * ctx[0] + u_i * pk[0] + e_0i), sum(u_i * pk[1] + e_1i)]

func (*PCKSProtocol) AllocateShare 

func (pcks *PCKSProtocol) AllocateShare(levelQ int) (s *PCKSShare)

AllocateShare allocates the shares of the PCKS protocol.

func (*PCKSProtocol) GenShare 

func (pcks *PCKSProtocol) GenShare(sk *rlwe.SecretKey, pk *rlwe.PublicKey, ct1 *ring.Poly, shareOut *PCKSShare)

GenShare is the first part of the unique round of the PCKSProtocol protocol. Each party computes the following :

[s_i * ct[1] + (u_i * pk[0] + e_0i)/P, (u_i * pk[1] + e_1i)/P]

and broadcasts the result to the other j-1 parties. ct1 is the degree 1 element of the rlwe.Ciphertext to keyswitch, i.e. ct1 = rlwe.Ciphertext.Value[1]. NTT flag for ct1 is expected to be set correctly.

func (*PCKSProtocol) KeySwitch 

func (pcks *PCKSProtocol) KeySwitch(ctIn *rlwe.Ciphertext, combined *PCKSShare, ctOut *rlwe.Ciphertext)

KeySwitch performs the actual keyswitching operation on a ciphertext ct and put the result in ctOut

func (*PCKSProtocol) ShallowCopy 

func (pcks *PCKSProtocol) ShallowCopy() *PCKSProtocol

ShallowCopy creates a shallow copy of PCKSProtocol in which all the read-only data-structures are shared with the receiver and the temporary buffers are reallocated. The receiver and the returned PCKSProtocol can be used concurrently.

type PCKSShare 

type PCKSShare struct {
	Value [2]*ring.Poly
}

PCKSShare represents a party's share in the PCKS protocol.

func (*PCKSShare) MarshalBinary 

func (share *PCKSShare) MarshalBinary() (data []byte, err error)

MarshalBinary encodes a PCKS share on a slice of bytes.

func (*PCKSShare) UnmarshalBinary 

func (share *PCKSShare) UnmarshalBinary(data []byte) (err error)

UnmarshalBinary decodes marshaled PCKS share on the target PCKS share.

type PublicKeySwitchingProtocol 

type PublicKeySwitchingProtocol interface {
	AllocateShare(levelQ int) *PCKSShare
	GenShare(skInput *rlwe.SecretKey, pkOutput *rlwe.PublicKey, c1 *ring.Poly, shareOut *PCKSShare)
	AggregateShare(share1, share2, shareOut *PCKSShare)
	KeySwitch(ctIn *rlwe.Ciphertext, combined *PCKSShare, ctOut *rlwe.Ciphertext)
}

PublicKeySwitchingProtocol is an interface describing the local steps of a generic RLWE PCKS protocol.

type RKGCRP 

type RKGCRP []rlwe.PolyQP

RKGCRP is a type for common reference polynomials in the RKG protocol.

type RKGProtocol 

type RKGProtocol struct {
	// contains filtered or unexported fields
}

RKGProtocol is the structure storing the parameters and and precomputations for the collective relinearization key generation protocol.

func NewRKGProtocol 

func NewRKGProtocol(params rlwe.Parameters) *RKGProtocol

NewRKGProtocol creates a new RKG protocol struct.

func (*RKGProtocol) AggregateShare 

func (ekg *RKGProtocol) AggregateShare(share1, share2, shareOut *RKGShare)

AggregateShare combines two RKG shares into a single one.

func (*RKGProtocol) AllocateShare 

func (ekg *RKGProtocol) AllocateShare() (ephSk *rlwe.SecretKey, r1 *RKGShare, r2 *RKGShare)

AllocateShare allocates the share of the EKG protocol.

func (*RKGProtocol) GenRelinearizationKey 

func (ekg *RKGProtocol) GenRelinearizationKey(round1 *RKGShare, round2 *RKGShare, evalKeyOut *rlwe.RelinearizationKey)

GenRelinearizationKey computes the generated RLK from the public shares and write the result in evalKeyOut.

func (*RKGProtocol) GenShareRoundOne 

func (ekg *RKGProtocol) GenShareRoundOne(sk *rlwe.SecretKey, crp RKGCRP, ephSkOut *rlwe.SecretKey, shareOut *RKGShare)

GenShareRoundOne is the first of three rounds of the RKGProtocol protocol. Each party generates a pseudo encryption of its secret share of the key s_i under its ephemeral key u_i : [-u_i*a + s_i*w + e_i] and broadcasts it to the other j-1 parties.

func (*RKGProtocol) GenShareRoundTwo 

func (ekg *RKGProtocol) GenShareRoundTwo(ephSk, sk *rlwe.SecretKey, round1 *RKGShare, shareOut *RKGShare)

GenShareRoundTwo is the second of three rounds of the RKGProtocol protocol. Upon receiving the j-1 shares, each party computes :

[s_i * sum([-u_j*a + s_j*w + e_j]) + e_i1, s_i*a + e_i2]

= [s_i * (-u*a + s*w + e) + e_i1, s_i*a + e_i2]

and broadcasts both values to the other j-1 parties.

func (*RKGProtocol) SampleCRP 

func (ekg *RKGProtocol) SampleCRP(crs CRS) RKGCRP

SampleCRP samples a common random polynomial to be used in the RKG protocol from the provided common reference string.

func (*RKGProtocol) ShallowCopy 

func (ekg *RKGProtocol) ShallowCopy() *RKGProtocol

ShallowCopy creates a shallow copy of RKGProtocol in which all the read-only data-structures are shared with the receiver and the temporary buffers are reallocated. The receiver and the returned RKGProtocol can be used concurrently.

type RKGShare 

type RKGShare struct {
	Value [][2]rlwe.PolyQP
}

RKGShare is a share in the RKG protocol.

func (*RKGShare) MarshalBinary 

func (share *RKGShare) MarshalBinary() ([]byte, error)

MarshalBinary encodes the target element on a slice of bytes.

func (*RKGShare) UnmarshalBinary 

func (share *RKGShare) UnmarshalBinary(data []byte) (err error)

UnmarshalBinary decodes a slice of bytes on the target element.

type RTGCRP 

type RTGCRP []rlwe.PolyQP

RTGCRP is a type for common reference polynomials in the RTG protocol.

type RTGProtocol 

type RTGProtocol struct {
	// contains filtered or unexported fields
}

RTGProtocol is the structure storing the parameters for the collective rotation-keys generation.

func NewRTGProtocol 

func NewRTGProtocol(params rlwe.Parameters) *RTGProtocol

NewRTGProtocol creates a RTGProtocol instance.

func (*RTGProtocol) AggregateShare 

func (rtg *RTGProtocol) AggregateShare(share1, share2, shareOut *RTGShare)

AggregateShare aggregates two share in the Rotation Key Generation protocol.

func (*RTGProtocol) AllocateShare 

func (rtg *RTGProtocol) AllocateShare() (rtgShare *RTGShare)

AllocateShare allocates a party's share in the RTG protocol.

func (*RTGProtocol) GenRotationKey 

func (rtg *RTGProtocol) GenRotationKey(share *RTGShare, crp RTGCRP, rotKey *rlwe.SwitchingKey)

GenRotationKey finalizes the RTG protocol and populates the input RotationKey with the computed collective SwitchingKey.

func (*RTGProtocol) GenShare 

func (rtg *RTGProtocol) GenShare(sk *rlwe.SecretKey, galEl uint64, crp RTGCRP, shareOut *RTGShare)

GenShare generates a party's share in the RTG protocol.

func (*RTGProtocol) SampleCRP 

func (rtg *RTGProtocol) SampleCRP(crs CRS) RTGCRP

SampleCRP samples a common random polynomial to be used in the RTG protocol from the provided common reference string.

func (*RTGProtocol) ShallowCopy 

func (rtg *RTGProtocol) ShallowCopy() *RTGProtocol

ShallowCopy creates a shallow copy of RTGProtocol in which all the read-only data-structures are shared with the receiver and the temporary buffers are reallocated. The receiver and the returned RTGProtocol can be used concurrently.

type RTGShare 

type RTGShare struct {
	Value []rlwe.PolyQP
}

RTGShare is represent a Party's share in the RTG protocol.

func (*RTGShare) MarshalBinary 

func (share *RTGShare) MarshalBinary() (data []byte, err error)

MarshalBinary encode the target element on a slice of byte.

func (*RTGShare) UnmarshalBinary 

func (share *RTGShare) UnmarshalBinary(data []byte) (err error)

UnmarshalBinary decodes a slice of bytes on the target element.

type RelinearizationKeyGenerator 

type RelinearizationKeyGenerator interface {
	AllocateShare() (ephKey *rlwe.SecretKey, r1 *RKGShare, r2 *RKGShare)
	GenShareRoundOne(sk *rlwe.SecretKey, crp RKGCRP, ephKeyOut *rlwe.SecretKey, shareOut *RKGShare)
	GenShareRoundTwo(ephSk, sk *rlwe.SecretKey, round1 *RKGShare, shareOut *RKGShare)
	AggregateShare(share1, share2, shareOut *RKGShare)
	GenRelinearizationKey(round1 *RKGShare, round2 *RKGShare, relinKeyOut *rlwe.RelinearizationKey)
}

RelinearizationKeyGenerator is an interface describing the local steps of a generic RLWE RKG protocol.

type RotationKeyGenerator 

type RotationKeyGenerator interface {
	AllocateShare() (rtgShare *RTGShare)
	GenShare(sk *rlwe.SecretKey, galEl uint64, crp RTGCRP, shareOut *RTGShare)
	AggregateShare(share1, share2, shareOut *RTGShare)
	GenRotationKey(share *RTGShare, crp RTGCRP, rotKey *rlwe.SwitchingKey)
}

RotationKeyGenerator is an interface for the local operation in the generation of rotation keys.

Source Files

View all Source files

Jump to

Keyboard shortcuts

? : This menu
/ : Search site
f or F : Jump to
y or Y : Canonical URL
go.dev uses cookies from Google to deliver and enhance the quality of its services and to analyze traffic. Learn more.