Struct TranscipheringServerKey 

pub struct TranscipheringServerKey { /* private fields */ }

Key material of the transciphering subsystem.

Taking this rather than a plain OprfServerKey is what keeps the ciphers from drawing their key material from the general purpose OPRF key or, through it, from the compute key.

Implementations

impl TranscipheringServerKey

pub fn new(sk: &TranscipheringPrivateKey, target_ck: &ClientKey) -> Result<Self>

pub fn oprf_key(&self) -> &OprfServerKey

pub fn from_raw_parts(oprf_key: OprfServerKey) -> Self

pub fn into_raw_parts(self) -> OprfServerKey

Trait Implementations

impl Clone for TranscipheringServerKey

fn clone(&self) -> TranscipheringServerKey

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl<'de> Deserialize<'de> for TranscipheringServerKey

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Named for TranscipheringServerKey

const NAME: &'static str = "transciphering::TranscipheringServerKey"

Default name for the type

const BACKWARD_COMPATIBILITY_ALIASES: &'static [&'static str] = _

Aliases that should also be accepted for backward compatibility when checking the name of values of this type

impl ParameterSetConformant for TranscipheringServerKey

The key bootstraps into the compute key, so it is checked against the compute parameters, plus the OPRF parameters it was generated with.

A key that does not match them makes the pseudo random generation it is used for panic.

type ParameterSet = OprfKeyConformanceParams

fn is_conformant(&self, parameter_set: &Self::ParameterSet) -> bool

impl Serialize for TranscipheringServerKey

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl Unversionize for TranscipheringServerKey

where TranscipheringServerKeyVersions: VersionsDispatch<Self>,

fn unversionize( versioned: Self::VersionedOwned, ) -> Result<Self, UnversionizeError>

Creates an object from a versioned enum, and eventually upgrades from previous variants.

impl UnversionizeVec for TranscipheringServerKey

where TranscipheringServerKeyVersions: VersionsDispatch<Self>,

fn unversionize_vec( versioned: Self::VersionedVec, ) -> Result<Vec<Self>, UnversionizeError>

impl Version for TranscipheringServerKey

where OprfServerKey: VersionizeOwned + Unversionize + Versionize,

type Ref<'vers> = TranscipheringServerKeyVersion<'vers>

type Owned = TranscipheringServerKeyVersionOwned

impl Versionize for TranscipheringServerKey

where TranscipheringServerKeyVersions: VersionsDispatch<Self>,

type Versioned<'vers> = <TranscipheringServerKeyVersions as VersionsDispatch<TranscipheringServerKey>>::Ref<'vers>

The equivalent versioned type. It should have a variant for each version. It may own the underlying data or only hold a read-only reference to it.

fn versionize(&self) -> Self::Versioned<'_>

Wraps the object into a versioned enum with a variant for each version. This will use references on the underlying types if possible.

impl VersionizeOwned for TranscipheringServerKey

where TranscipheringServerKeyVersions: VersionsDispatch<Self>,

type VersionedOwned = <TranscipheringServerKeyVersions as VersionsDispatch<TranscipheringServerKey>>::Owned

fn versionize_owned(self) -> Self::VersionedOwned

Wraps the object into a versioned enum with a variant for each version. This will clone the underlying types.

impl VersionizeSlice for TranscipheringServerKey

where TranscipheringServerKeyVersions: VersionsDispatch<Self>,

type VersionedSlice<'vers> = Vec<<TranscipheringServerKey as Versionize>::Versioned<'vers>>

fn versionize_slice(slice: &[Self]) -> Self::VersionedSlice<'_>

impl VersionizeVec for TranscipheringServerKey

where TranscipheringServerKeyVersions: VersionsDispatch<Self>,

type VersionedVec = Vec<<TranscipheringServerKey as VersionizeOwned>::VersionedOwned>

fn versionize_vec(vec: Vec<Self>) -> Self::VersionedVec

impl VersionsDispatch<TranscipheringServerKey> for TranscipheringServerKeyVersions

where TranscipheringServerKey: Version,

type Ref<'vers> = TranscipheringServerKeyVersionsDispatch<'vers>

type Owned = TranscipheringServerKeyVersionsDispatchOwned