Struct ClientKey

pub struct ClientKey { /* private fields */ }

Available on crate feature integer only.

Key of the client

This struct contains the keys that are of interest to the user as they will allow to encrypt and decrypt data.

This key MUST NOT be sent to the server.

Implementations

impl ClientKey

pub fn generate<C: Into<Config>>(config: C) -> Self

Generates a new key from the given config.

pub fn generate_with_seed<C: Into<Config>>(config: C, seed: Seed) -> Self

Generates a key from a config and uses a seed.

Using the same seed between generations allows to regenerate the same key.

use tfhe::{ClientKey, ConfigBuilder, Seed};

let builder = ConfigBuilder::default();
let config = builder.build();

let cks1 = ClientKey::generate_with_seed(config, Seed(125));
let cks2 = ClientKey::generate(config);
let cks3 = ClientKey::generate_with_seed(config, Seed(125));

// The keys created with the same seed are equal
assert_eq!(
    bincode::serialize(&cks1).unwrap(),
    bincode::serialize(&cks3).unwrap()
);
// Which is not the case for keys not created using the same seed
assert_ne!(
    bincode::serialize(&cks1).unwrap(),
    bincode::serialize(&cks2).unwrap()
);

pub fn computation_parameters(&self) -> PBSParameters

pub fn into_raw_parts( self, ) -> (ClientKey, Option<(CompactPrivateKey<Vec<u64>>, ShortintKeySwitchingParameters)>, Option<CompressionPrivateKeys>, Tag)

pub fn from_raw_parts( key: ClientKey, dedicated_compact_private_key: Option<(CompactPrivateKey<Vec<u64>>, ShortintKeySwitchingParameters)>, compression_key: Option<CompressionPrivateKeys>, tag: Tag, ) -> Self

pub fn generate_server_key(&self) -> ServerKey

Generates a new ServerKey

The ServerKey generated is meant to be used to initialize the global state using crate::high_level_api::set_server_key.

pub fn generate_compressed_server_key(&self) -> CompressedServerKey

Generates a new CompressedServerKey

Trait Implementations

impl AsRef<ClientKey> for ClientKey

fn as_ref(&self) -> &ClientKey

Converts this type into a shared reference of the (usually inferred) input type.

impl Clone for ClientKey

fn clone(&self) -> ClientKey

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for ClientKey

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for ClientKey

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl<'a, Clear, Id> FheTryEncrypt<&'a [Clear], ClientKey> for CpuFheIntArray<Id>

where Id: FheIntId, Clear: DecomposableInto<u64> + SignedNumeric,

type Error = Error

fn try_encrypt( clears: &'a [Clear], key: &ClientKey, ) -> Result<Self, Self::Error>

impl<'a, Clear, Id> FheTryEncrypt<&'a [Clear], ClientKey> for FheUintArray<Id>

where Id: FheUintId, Clear: DecomposableInto<u64> + UnsignedNumeric,

type Error = Error

fn try_encrypt( clears: &'a [Clear], key: &ClientKey, ) -> Result<Self, Self::Error>

impl<'a, Clear, Id> FheTryEncrypt<&'a [Clear], ClientKey> for GpuFheIntArray<Id>

where Id: FheIntId, Clear: DecomposableInto<u64> + SignedNumeric,

Available on crate feature gpu only.

type Error = Error

fn try_encrypt( clears: &'a [Clear], key: &ClientKey, ) -> Result<Self, Self::Error>

impl<'a, Clear, Id> FheTryEncrypt<&'a [Clear], ClientKey> for FheArrayBase<GpuOwned<CudaUnsignedRadixCiphertext>, Id>

where Id: FheUintId, Clear: DecomposableInto<u64> + UnsignedNumeric,

Available on crate feature gpu only.

type Error = Error

fn try_encrypt( clears: &'a [Clear], key: &ClientKey, ) -> Result<Self, Self::Error>

impl<'a, Clear, Id> FheTryEncrypt<&'a [Clear], ClientKey> for FheArrayBase<InnerIntArray, Id>

where Id: FheIntId, Clear: DecomposableInto<u64> + SignedNumeric,

type Error = Error

fn try_encrypt( clears: &'a [Clear], key: &ClientKey, ) -> Result<Self, Self::Error>

impl<'a, Clear, Id> FheTryEncrypt<&'a [Clear], ClientKey> for FheArrayBase<Vec<RadixCiphertext>, Id>

where Id: FheUintId, Clear: DecomposableInto<u64> + UnsignedNumeric,

type Error = Error

fn try_encrypt( clears: &'a [Clear], key: &ClientKey, ) -> Result<Self, Self::Error>

impl FheTryEncrypt<&[bool], ClientKey> for CpuFheBoolArray

type Error = Error

fn try_encrypt(values: &[bool], cks: &ClientKey) -> Result<Self, Self::Error>

impl<'a> FheTryEncrypt<&'a [bool], ClientKey> for FheBoolArray

type Error = Error

fn try_encrypt(value: &'a [bool], key: &ClientKey) -> Result<Self, Self::Error>

impl FheTryEncrypt<&[bool], ClientKey> for GpuFheBoolArray

Available on crate feature gpu only.

type Error = Error

fn try_encrypt(values: &[bool], cks: &ClientKey) -> Result<Self, Self::Error>

impl<'a, Clear, Id> FheTryEncrypt<(&'a [Clear], Vec<usize>), ClientKey> for FheUintArray<Id>

where Id: FheUintId, Clear: DecomposableInto<u64> + UnsignedNumeric,

type Error = Error

fn try_encrypt( (clears, shape): (&'a [Clear], Vec<usize>), key: &ClientKey, ) -> Result<Self, Self::Error>

impl<'a, Clear, Id> FheTryEncrypt<(&'a [Clear], Vec<usize>), ClientKey> for FheArrayBase<GpuOwned<CudaUnsignedRadixCiphertext>, Id>

where Id: FheUintId, Clear: DecomposableInto<u64> + UnsignedNumeric,

Available on crate feature gpu only.

type Error = Error

fn try_encrypt( (clears, shape): (&'a [Clear], Vec<usize>), key: &ClientKey, ) -> Result<Self, Self::Error>

impl<'a, Clear, Id> FheTryEncrypt<(&'a [Clear], Vec<usize>), ClientKey> for FheArrayBase<Vec<RadixCiphertext>, Id>

where Id: FheUintId, Clear: DecomposableInto<u64> + UnsignedNumeric,

type Error = Error

fn try_encrypt( (clears, shape): (&'a [Clear], Vec<usize>), key: &ClientKey, ) -> Result<Self, Self::Error>

impl<Id, T> FheTryEncrypt<T, ClientKey> for CompressedFheInt<Id>

where Id: FheIntId, T: DecomposableInto<u64> + SignedNumeric,

type Error = Error

fn try_encrypt(value: T, key: &ClientKey) -> Result<Self, Self::Error>

impl<Id, T> FheTryEncrypt<T, ClientKey> for CompressedFheUint<Id>

where Id: FheUintId, T: DecomposableInto<u64> + UnsignedNumeric,

type Error = Error

fn try_encrypt(value: T, key: &ClientKey) -> Result<Self, Self::Error>

impl<Id, T> FheTryEncrypt<T, ClientKey> for FheInt<Id>

where Id: FheIntId, T: DecomposableInto<u64> + SignedNumeric,

type Error = Error

fn try_encrypt(value: T, key: &ClientKey) -> Result<Self, Self::Error>

impl<Id, T> FheTryEncrypt<T, ClientKey> for FheUint<Id>

where Id: FheUintId, T: DecomposableInto<u64> + UnsignedNumeric,

type Error = Error

fn try_encrypt(value: T, key: &ClientKey) -> Result<Self, Self::Error>

impl FheTryEncrypt<bool, ClientKey> for CompressedFheBool

fn try_encrypt(value: bool, key: &ClientKey) -> Result<Self, Self::Error>

Creates a compressed encryption of a boolean value

type Error = Error

impl FheTryEncrypt<bool, ClientKey> for FheBool

type Error = Error

fn try_encrypt(value: bool, key: &ClientKey) -> Result<Self, Self::Error>

impl Named for ClientKey

const NAME: &'static str = "high_level_api::ClientKey"

impl Serialize for ClientKey

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

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl Tagged for ClientKey

fn tag(&self) -> &Tag

fn tag_mut(&mut self) -> &mut Tag

impl Unversionize for ClientKey

where ClientKeyVersions: 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 ClientKey

where ClientKeyVersions: VersionsDispatch<Self>,

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

impl Upgrade<ClientKey> for ClientKeyV0

type Error = Infallible

fn upgrade(self) -> Result<ClientKey, Self::Error>

impl Version for ClientKey

where IntegerClientKey: VersionizeOwned + Unversionize + Versionize, Tag: VersionizeOwned + Unversionize + Versionize,

type Ref<'vers> = ClientKeyVersion<'vers>

type Owned = ClientKeyVersionOwned

impl Versionize for ClientKey

where ClientKeyVersions: VersionsDispatch<Self>,

type Versioned<'vers> = <ClientKeyVersions as VersionsDispatch<ClientKey>>::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 ClientKey

where ClientKeyVersions: VersionsDispatch<Self>,

type VersionedOwned = <ClientKeyVersions as VersionsDispatch<ClientKey>>::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 ClientKey

where ClientKeyVersions: VersionsDispatch<Self>,

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

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

impl VersionizeVec for ClientKey

where ClientKeyVersions: VersionsDispatch<Self>,

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

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

impl VersionsDispatch<ClientKey> for ClientKeyVersions

where ClientKeyV0: Version + Upgrade<ClientKey>, ClientKey: Version,

type Ref<'vers> = ClientKeyVersionsDispatch<'vers>

type Owned = ClientKeyVersionsDispatchOwned