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(parameter_set: Parameters) -> Self

Creates a Client Key.

Example

use concrete_integer::ClientKey;
use concrete_shortint::parameters::PARAM_MESSAGE_2_CARRY_2;

// 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);

pub fn parameters(&self) -> Parameters

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

Encrypts an integer in radix decomposition

Example

use concrete_integer::ClientKey;
use concrete_shortint::parameters::PARAM_MESSAGE_2_CARRY_2;

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

let msg = 167_u64;

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

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

pub fn encrypt_radix_without_padding( &self, message: u64, num_blocks: usize, ) -> RadixCiphertext

Encrypts an integer in radix decomposition without padding bit

Example

use concrete_integer::ClientKey;
use concrete_shortint::parameters::PARAM_MESSAGE_2_CARRY_2;

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

let msg = 167_u64;

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

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

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

Encrypts one block.

This returns a shortint ciphertext.

Example

use concrete_integer::ClientKey;
use concrete_shortint::parameters::PARAM_MESSAGE_2_CARRY_2;

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

let msg = 2_u64;

// Encryption
let ct = cks.encrypt_one_block(msg);

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

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

Decrypts one block.

This takes a shortint ciphertext as input.

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

Decrypts a ciphertext encrypting an radix integer

Example

use concrete_integer::ClientKey;
use concrete_shortint::parameters::PARAM_MESSAGE_2_CARRY_2;

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

let msg = 191_u64;

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

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

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

Decrypts a ciphertext encrypting an radix integer encrypted without padding

Example

use concrete_integer::ClientKey;
use concrete_shortint::parameters::PARAM_MESSAGE_2_CARRY_2;

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

let msg = 191_u64;

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

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

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

Encrypts an integer using crt representation

Example

use concrete_integer::ClientKey;
use concrete_shortint::parameters::PARAM_MESSAGE_2_CARRY_2;

let cks = ClientKey::new(PARAM_MESSAGE_2_CARRY_2);

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 decrypt_crt(&self, ctxt: &CrtCiphertext) -> u64

Decrypts an integer in crt decomposition

Example

use concrete_integer::ClientKey;
use concrete_shortint::parameters::PARAM_MESSAGE_2_CARRY_2;

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

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

// Encryption:
let mut 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 concrete_integer::ClientKey;
use concrete_shortint::parameters::PARAM_MESSAGE_3_CARRY_3;

let cks = ClientKey::new(PARAM_MESSAGE_3_CARRY_3);

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 decrypt_native_crt(&self, ct: &CrtCiphertext) -> u64

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

Example

use concrete_integer::ClientKey;
use concrete_shortint::parameters::PARAM_MESSAGE_3_CARRY_3;

let cks = ClientKey::new(PARAM_MESSAGE_3_CARRY_3);

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

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

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

fn from(key: ClientKey) -> ClientKey

Converts to this type from the input type.

impl PartialEq for ClientKey

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

Tests for self and other values to be equal, and is used by ==.

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

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

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