Struct ClientKey 

pub struct ClientKey { /* private fields */ }

A structure containing the client key, which must be kept secret.

This key can be used to encrypt both in Radix and CRT decompositions.

Using this key, for both decompositions, each block will use the same crypto parameters.

Implementations

impl ClientKey

pub fn new<P>(parameter_set: P) -> Self

where P: TryInto<ShortintParameters>, <P as TryInto<ShortintParameters>>::Error: Debug,

Creates a Client Key.

Example

use tfhe::integer::ClientKey;
use tfhe::shortint::parameters::PARAM_MESSAGE_2_CARRY_2_KS_PBS_GAUSSIAN_2M128;

// Generate the client key, that can encrypt in
// radix and crt decomposition, where each block of the decomposition
// have over 2 bits of message modulus.
let cks = ClientKey::new(PARAM_MESSAGE_2_CARRY_2_KS_PBS_GAUSSIAN_2M128);

pub fn into_raw_parts(self) -> ShortintClientKey

Deconstruct a ClientKey into its constituents.

Example

use tfhe::integer::ClientKey;
use tfhe::shortint::parameters::PARAM_MESSAGE_2_CARRY_2_KS_PBS_GAUSSIAN_2M128;

// Generate the client key, that can encrypt in
// radix and crt decomposition, where each block of the decomposition
// have over 2 bits of message modulus.
let cks = ClientKey::new(PARAM_MESSAGE_2_CARRY_2_KS_PBS_GAUSSIAN_2M128);

let key = cks.into_raw_parts();

pub fn from_raw_parts(key: ShortintClientKey) -> Self

Construct a ClientKey from its constituents.

Example

use tfhe::integer::ClientKey;
use tfhe::shortint::parameters::PARAM_MESSAGE_2_CARRY_2_KS_PBS_GAUSSIAN_2M128;

// Generate the client key, that can encrypt in
// radix and crt decomposition, where each block of the decomposition
// have over 2 bits of message modulus.
let cks = ClientKey::new(PARAM_MESSAGE_2_CARRY_2_KS_PBS_GAUSSIAN_2M128);

let key = cks.into_raw_parts();

let cks = ClientKey::from_raw_parts(key);

pub fn parameters(&self) -> AtomicPatternParameters

pub fn encrypt_radix<T>(&self, message: T, num_blocks: usize) -> RadixCiphertext

where T: DecomposableInto<u64> + UnsignedNumeric,

Encrypts an integer in radix decomposition

Example

use tfhe::integer::ClientKey;
use tfhe::shortint::parameters::PARAM_MESSAGE_2_CARRY_2_KS_PBS_GAUSSIAN_2M128;

let cks = ClientKey::new(PARAM_MESSAGE_2_CARRY_2_KS_PBS_GAUSSIAN_2M128);
let num_block = 4;

let msg = 167_u64;

// 2 * 4 = 8 bits of message
let ct = cks.encrypt_radix(msg, num_block);

let dec = cks.decrypt_radix(&ct);
assert_eq!(msg, dec);

pub fn encrypt_radix_without_padding<T: DecomposableInto<u64> + UnsignedNumeric>( &self, message: T, num_blocks: usize, ) -> RadixCiphertext

Encrypts an integer in radix decomposition without padding bit

Example

use tfhe::integer::ClientKey;
use tfhe::shortint::parameters::PARAM_MESSAGE_2_CARRY_2_KS_PBS_GAUSSIAN_2M128;

let cks = ClientKey::new(PARAM_MESSAGE_2_CARRY_2_KS_PBS_GAUSSIAN_2M128);
let num_block = 4;

let msg = 167_u64;

// 2 * 4 = 8 bits of message
let ct = cks.encrypt_radix_without_padding(msg, num_block);

let dec = cks.decrypt_radix_without_padding(&ct);
assert_eq!(msg, dec);

pub fn encrypt_radix_compressed<T: DecomposableInto<u64> + UnsignedNumeric>( &self, message: T, num_blocks: usize, ) -> CompressedRadixCiphertext

pub fn encrypt_radix_without_padding_compressed<T: DecomposableInto<u64> + UnsignedNumeric>( &self, message: T, num_blocks: usize, ) -> CompressedRadixCiphertext

pub fn encrypt_words_radix<Block, RadixCiphertextType, T, F>( &self, message_words: T, num_blocks: usize, encrypt_block: F, ) -> RadixCiphertextType

where T: DecomposableInto<u64> + UnsignedNumeric, F: Fn(&ClientKey, u64) -> Block, RadixCiphertextType: From<Vec<Block>>,

Encrypts 64-bits words into a ciphertext in radix decomposition

The words are assumed to be in little endian order.

If there are not enough words for the requested num_block, encryptions of zeros will be appended.

pub fn decrypt_radix<T>(&self, ctxt: &RadixCiphertext) -> T

where T: RecomposableFrom<u64> + UnsignedNumeric,

Decrypts a ciphertext encrypting an radix integer

Example

use tfhe::integer::ClientKey;
use tfhe::shortint::parameters::PARAM_MESSAGE_2_CARRY_2_KS_PBS_GAUSSIAN_2M128;

let cks = ClientKey::new(PARAM_MESSAGE_2_CARRY_2_KS_PBS_GAUSSIAN_2M128);
let num_block = 4;

let msg = 191_u64;

let ct = cks.encrypt_radix(msg, num_block);

let dec = cks.decrypt_radix(&ct);
assert_eq!(msg, dec);

pub fn decrypt_radix_without_padding<T>(&self, ctxt: &RadixCiphertext) -> T

where T: RecomposableFrom<u64> + UnsignedNumeric,

Decrypts a ciphertext encrypting an radix integer encrypted without padding

Example

use tfhe::integer::ClientKey;
use tfhe::shortint::parameters::PARAM_MESSAGE_2_CARRY_2_KS_PBS_GAUSSIAN_2M128;

let cks = ClientKey::new(PARAM_MESSAGE_2_CARRY_2_KS_PBS_GAUSSIAN_2M128);
let num_block = 4;

let msg = 191_u64;

let ct = cks.encrypt_radix_without_padding(msg, num_block);

let dec = cks.decrypt_radix_without_padding(&ct);
assert_eq!(msg, dec);

pub fn encrypt_signed_radix<T>( &self, message: T, num_blocks: usize, ) -> SignedRadixCiphertext

where T: DecomposableInto<u64> + SignedNumeric,

pub fn encrypt_signed_radix_without_padding<T>( &self, message: T, num_blocks: usize, ) -> SignedRadixCiphertext

where T: DecomposableInto<u64> + SignedNumeric,

pub fn encrypt_signed_radix_compressed<T: DecomposableInto<u64> + SignedNumeric>( &self, message: T, num_blocks: usize, ) -> CompressedSignedRadixCiphertext

pub fn encrypt_signed_radix_without_padding_compressed<T: DecomposableInto<u64> + SignedNumeric>( &self, message: T, num_blocks: usize, ) -> CompressedSignedRadixCiphertext

pub fn decrypt_signed_radix<T>(&self, ctxt: &SignedRadixCiphertext) -> T

where T: RecomposableSignedInteger,

pub fn decrypt_signed_radix_impl<T, F>( &self, ctxt: &SignedRadixCiphertext, decrypt_block: F, ) -> T

where T: RecomposableSignedInteger, F: Fn(&ClientKey, &Ciphertext) -> u64,

pub fn encrypt_one_block(&self, message: u64) -> Ciphertext

Encrypts one block.

This returns a shortint ciphertext.

Example

use tfhe::integer::ClientKey;
use tfhe::shortint::parameters::PARAM_MESSAGE_2_CARRY_2_KS_PBS_GAUSSIAN_2M128;

let cks = ClientKey::new(PARAM_MESSAGE_2_CARRY_2_KS_PBS_GAUSSIAN_2M128);

let msg = 2_u64;

let ct = cks.encrypt_one_block(msg);

let dec = cks.decrypt_one_block(&ct);
assert_eq!(msg, dec);

pub fn encrypt_bool(&self, msg: bool) -> BooleanBlock

Encrypts a bool to a BooleanBlock

Example

use tfhe::integer::gen_keys_radix;
use tfhe::shortint::parameters::PARAM_MESSAGE_2_CARRY_2_KS_PBS_GAUSSIAN_2M128;

// We have 4 * 2 = 8 bits of message
let size = 4;
let (cks, sks) = gen_keys_radix(PARAM_MESSAGE_2_CARRY_2_KS_PBS_GAUSSIAN_2M128, size);

let a = cks.encrypt_bool(false);
let dec = cks.decrypt_bool(&a);
assert!(!dec);

let a = a.into_radix(size, &sks);
let dec: u64 = cks.decrypt(&a);
assert_eq!(dec, 0);

pub fn decrypt_one_block(&self, ct: &Ciphertext) -> u64

Decrypts one block.

This takes a shortint ciphertext as input.

pub fn decrypt_bool(&self, ct: &BooleanBlock) -> bool

Decrypts a ciphertext marked as holding a boolean value to a bool

Treats 0 as false and the rest as true

Example

use tfhe::integer::{BooleanBlock, ClientKey};
use tfhe::shortint::parameters::PARAM_MESSAGE_2_CARRY_2_KS_PBS_GAUSSIAN_2M128;

let cks = ClientKey::new(PARAM_MESSAGE_2_CARRY_2_KS_PBS_GAUSSIAN_2M128);

let a = cks.encrypt_one_block(1u64);
let wrapped = BooleanBlock::new_unchecked(a);
let dec = cks.decrypt_bool(&wrapped);
assert!(dec);

pub fn encrypt_crt(&self, message: u64, base_vec: Vec<u64>) -> CrtCiphertext

Encrypts an integer using crt representation

Example

use tfhe::integer::ClientKey;
use tfhe::shortint::parameters::PARAM_MESSAGE_2_CARRY_2_KS_PBS_GAUSSIAN_2M128;

let cks = ClientKey::new(PARAM_MESSAGE_2_CARRY_2_KS_PBS_GAUSSIAN_2M128);

let msg = 13_u64;

// Encryption:
let basis: Vec<u64> = vec![2, 3, 5];
let ct = cks.encrypt_crt(msg, basis);

// Decryption:
let dec = cks.decrypt_crt(&ct);
assert_eq!(msg, dec);

pub fn encrypt_crt_compressed( &self, message: u64, base_vec: Vec<u64>, ) -> CompressedCrtCiphertext

pub fn decrypt_crt(&self, ctxt: &CrtCiphertext) -> u64

Decrypts an integer in crt decomposition

Example

use tfhe::integer::ClientKey;
use tfhe::shortint::parameters::PARAM_MESSAGE_2_CARRY_2_KS_PBS_GAUSSIAN_2M128;

// Generate the client key and the server key:
let cks = ClientKey::new(PARAM_MESSAGE_2_CARRY_2_KS_PBS_GAUSSIAN_2M128);

let msg = 27_u64;
let basis: Vec<u64> = vec![2, 3, 5];

// Encryption:
let ct = cks.encrypt_crt(msg, basis);

// Decryption:
let dec = cks.decrypt_crt(&ct);
assert_eq!(msg, dec);

pub fn encrypt_native_crt( &self, message: u64, base_vec: Vec<u64>, ) -> CrtCiphertext

Encrypts a small integer message using the client key and some moduli without padding bit.

Example

use tfhe::integer::ClientKey;
use tfhe::shortint::parameters::PARAM_MESSAGE_3_CARRY_3_KS_PBS_GAUSSIAN_2M128;

let cks = ClientKey::new(PARAM_MESSAGE_3_CARRY_3_KS_PBS_GAUSSIAN_2M128);

let msg = 13_u64;

// Encryption of one message:
let basis: Vec<u64> = vec![2, 3, 5];
let ct = cks.encrypt_native_crt(msg, basis);

// Decryption:
let dec = cks.decrypt_native_crt(&ct);
assert_eq!(msg, dec);

pub fn encrypt_native_crt_compressed( &self, message: u64, base_vec: Vec<u64>, ) -> CompressedCrtCiphertext

pub fn decrypt_native_crt(&self, ct: &CrtCiphertext) -> u64

Decrypts a ciphertext encrypting an integer message with some moduli basis without padding bit.

Example

use tfhe::integer::ClientKey;
use tfhe::shortint::parameters::PARAM_MESSAGE_3_CARRY_3_KS_PBS_GAUSSIAN_2M128;

let cks = ClientKey::new(PARAM_MESSAGE_3_CARRY_3_KS_PBS_GAUSSIAN_2M128);

let msg = 27_u64;
let basis: Vec<u64> = vec![2, 3, 5];
// Encryption of one message:
let ct = cks.encrypt_native_crt(msg, basis);

// Decryption:
let dec = cks.decrypt_native_crt(&ct);
assert_eq!(msg, dec);

pub fn new_compression_private_key( &self, params: CompressionParameters, ) -> CompressionPrivateKeys

pub fn new_compression_decompression_keys( &self, private_compression_key: &CompressionPrivateKeys, ) -> (CompressionKey, DecompressionKey)

impl ClientKey

pub fn new_compressed_compression_decompression_keys( &self, private_compression_key: &CompressionPrivateKeys, ) -> (CompressedCompressionKey, CompressedDecompressionKey)

impl ClientKey

pub fn new_compressed_noise_squashing_key( &self, noise_squashing_private_key: &NoiseSquashingPrivateKey, ) -> CompressedNoiseSquashingKey

pub fn new_noise_squashing_key( &self, noise_squashing_private_key: &NoiseSquashingPrivateKey, ) -> NoiseSquashingKey

Trait Implementations

impl AsRef<ClientKey> for CrtClientKey

fn as_ref(&self) -> &ClientKey

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

impl AsRef<ClientKey> for RadixClientKey

fn as_ref(&self) -> &ClientKey

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

impl AsRef<ClientKey> for ClientKey

fn as_ref(&self) -> &Self

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

impl AsRef<ClientKey> for ClientKey

fn as_ref(&self) -> &ClientKey

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

impl AsRef<GenericClientKey<AtomicPatternClientKey>> for ClientKey

fn as_ref(&self) -> &ShortintClientKey

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

impl Clone for ClientKey

fn clone(&self) -> ClientKey

Returns a duplicate 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 From<ClientKey> for ClientKey

fn from(key: ClientKey) -> Self

Converts to this type from the input type.

impl From<GenericClientKey<AtomicPatternClientKey>> for ClientKey

fn from(key: ShortintClientKey) -> Self

Converts to this type from the input type.

impl From<RadixClientKey> for ClientKey

fn from(ck: RadixClientKey) -> Self

Converts to this type from the input type.

impl PartialEq for ClientKey

fn eq(&self, other: &ClientKey) -> bool

Equality operator ==.

fn ne(&self, other: &Rhs) -> bool

Inequality operator !=.

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 StructuralPartialEq for ClientKey

impl<'key> TryFrom<&'key ClientKey> for CompactPrivateKey<&'key [u64]>

type Error = Error

The type returned in the event of a conversion error.

fn try_from(client_key: &'key ClientKey) -> Result<Self, Self::Error>

Performs the conversion.

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 Version for ClientKey

where ShortintClientKey: 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 ClientKey: Version,

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

type Owned = ClientKeyVersionsDispatchOwned