Struct bfv12::SecretKey

pub struct SecretKey { /* private fields */ }

A BFV12 Secret Key

Implementations

impl SecretKey

pub fn generate<T: RngCore + CryptoRng>(degree: usize, rng: &mut T) -> SecretKey

Generate a secret key by sampling the coefficients of s uniformly from R_2, which in this implementation is the set {0, 1}.

• degree: the polynomial degree of the secret key
• rng: the RNG used to generate randomness

use bfv12::SecretKey;

let degree = 4;
let secret_key = SecretKey::generate(degree, &mut rng);

pub fn public_key_gen<T: RngCore + CryptoRng>(
    &self,
    q: i64,
    std_dev: f64,
    rng: &mut T
) -> PublicKey

Generate a public key from a secret key.

• q: the ciphertext modulus
• std_dev: the standard deviation for error generation
• rng: the RNG used to generate randomness

use bfv12::SecretKey;

let degree = 4;
let std_dev = 3.2;
let q = 65536;

let secret_key = SecretKey::generate(degree, &mut rng);
let public_key = secret_key.public_key_gen(q, std_dev, &mut rng);

pub fn relin_key_gen_1<T: RngCore + CryptoRng>(
    &self,
    q: i64,
    std_dev: f64,
    rng: &mut T,
    base: i64
) -> RelinearizationKey1

Generate a relinearization key, using the approach in Version 1

• q: the ciphertext modulus
• std_dev: the standard deviation for error generation
• rng: the RNG used to generate randomness
• base: the decomposition base used for relinearization

Note on base selection: The base can be chosen to trade off relinearisation time and space, for error accumulation. The larger the base, the larger the error. The bounds on the base are discussed in the paper. Choosing T = ceil(sqrt(q)) will minimize relinearisation time and space, at the expense of error. Choosing T = log_2(q) will decrease error at the cost of relinearisation time and space.

use bfv12::SecretKey;

let degree = 4;
let std_dev = 3.2;
let q = 65536;
let rlk_base = (q as f64).log2() as i64;

let secret_key = SecretKey::generate(degree, &mut rng);
let relin_key_1 = secret_key.relin_key_gen_1(q, std_dev, &mut rng, rlk_base);

pub fn relin_key_gen_2<T: RngCore + CryptoRng>(
    &self,
    q: i64,
    std_dev: f64,
    rng: &mut T,
    p: i64
) -> RelinearizationKey2

Generate a relinearization key, using the approach in Version 2

• q: the ciphertext modulus
• std_dev: the standard deviation for error generation
• rng: the RNG used to generate randomness
• p: the amount to scale the modulus, during modulus switching

Note on p selection: Technically p needs to be >= q^3 for security (see paper discussion on Relinearization Version 2), However, setting p = q^3 results in an overflow when taking p * q. Therefore, in this library we will test with a smaller p, and recommend using Relinearization Version 1.

use bfv12::SecretKey;

let degree = 4;
let std_dev = 3.2;
let q = 65536;
let p = 2_i64.pow(13) * q;

let secret_key = SecretKey::generate(degree, &mut rng);
let relin_key_2 = secret_key.relin_key_gen_2(q, std_dev, &mut rng, p);

Trait Implementations

impl Clone for SecretKey

fn clone(&self) -> SecretKey

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for SecretKey

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

Formats the value using the given formatter.