github/tfhe-rs
1
1
Fork 0
mirror of https://github.com/zama-ai/tfhe-rs.git synced 2026-01-08 22:28:01 -05:00
Code Issues Packages Projects Releases Wiki Activity

chore(csprng)!: moved the RandomGenerator detector into tfhe-csprng

Browse Source
This commit is contained in:
Nicolas Sarlin
2024-12-13 14:45:57 +01:00
committed by Nicolas Sarlin
parent 1ede004e9a
commit c41b76f892
76 changed files with 423 additions and 545 deletions
Download Patch File Download Diff File Expand all files Collapse all files

16
tfhe-csprng/benches/benchmark.rs
View File

@@ -1,9 +1,7 @@
use criterion::{black_box, criterion_group, criterion_main, Criterion};
#[cfg(all(target_arch = "x86_64", target_feature = "aes"))]
use tfhe_csprng::generators::AesniRandomGenerator as ActivatedRandomGenerator;
#[cfg(not(all(target_arch = "x86_64", target_feature = "aes")))]
use tfhe_csprng::generators::SoftwareRandomGenerator as ActivatedRandomGenerator;
use tfhe_csprng::generators::{BytesPerChild, ChildrenCount, RandomGenerator};
use tfhe_csprng::generators::{
BytesPerChild, ChildrenCount, DefaultRandomGenerator, RandomGenerator,
};
#[cfg(target_os = "macos")]
use tfhe_csprng::seeders::AppleSecureEnclaveSeeder as ActivatedSeeder;
#[cfg(all(
@@ -49,7 +47,7 @@ fn new_seeder() -> ActivatedSeeder {
fn parent_generate(c: &mut Criterion) {
let mut seeder = new_seeder();
let mut generator = ActivatedRandomGenerator::new(seeder.seed());
let mut generator = DefaultRandomGenerator::new(seeder.seed());
c.bench_function("parent_generate", |b| {
b.iter(|| {
(0..N_GEN).for_each(|_| {
@@ -60,8 +58,8 @@ fn parent_generate(c: &mut Criterion) {
}
fn child_generate(c: &mut Criterion) {
let mut seeder = new_seeder;
let mut generator = ActivatedRandomGenerator::new(seeder.seed());
let mut seeder = new_seeder();
let mut generator = DefaultRandomGenerator::new(seeder.seed());
let mut generator = generator
.try_fork(ChildrenCount(1), BytesPerChild(N_GEN * 10_000))
.unwrap()
@@ -78,7 +76,7 @@ fn child_generate(c: &mut Criterion) {
fn fork(c: &mut Criterion) {
let mut seeder = new_seeder();
let mut generator = ActivatedRandomGenerator::new(seeder.seed());
let mut generator = DefaultRandomGenerator::new(seeder.seed());
c.bench_function("fork", |b| {
b.iter(|| {
black_box(

35
tfhe-csprng/examples/generate.rs
View File

@@ -2,32 +2,7 @@
//! the program stdout. It can also generate a fixed number of bytes by passing a value along the
//! optional argument `--bytes_total`. For testing purpose.
use clap::{value_parser, Arg, Command};
#[cfg(all(
target_arch = "x86_64",
target_feature = "aes",
target_feature = "sse2"
))]
use tfhe_csprng::generators::AesniRandomGenerator as ActivatedRandomGenerator;
#[cfg(all(
target_arch = "aarch64",
target_feature = "aes",
target_feature = "neon"
))]
use tfhe_csprng::generators::NeonAesRandomGenerator as ActivatedRandomGenerator;
use tfhe_csprng::generators::RandomGenerator;
#[cfg(all(
not(all(
target_arch = "x86_64",
target_feature = "aes",
target_feature = "sse2"
)),
not(all(
target_arch = "aarch64",
target_feature = "aes",
target_feature = "neon"
)),
))]
use tfhe_csprng::generators::SoftwareRandomGenerator as ActivatedRandomGenerator;
use tfhe_csprng::generators::{DefaultRandomGenerator, RandomGenerator};
use std::io::prelude::*;
use std::io::{stdout, StdoutLock};
@@ -49,7 +24,7 @@ use tfhe_csprng::seeders::UnixSeeder as ActivatedSeeder;
fn write_bytes(
buffer: &mut [u8],
generator: &mut ActivatedRandomGenerator,
generator: &mut DefaultRandomGenerator,
stdout: &mut StdoutLock<'_>,
) -> std::io::Result<()> {
buffer.iter_mut().zip(generator).for_each(|(b, g)| *b = g);
@@ -58,7 +33,7 @@ fn write_bytes(
fn infinite_bytes_generation(
buffer: &mut [u8],
generator: &mut ActivatedRandomGenerator,
generator: &mut DefaultRandomGenerator,
stdout: &mut StdoutLock<'_>,
) {
while write_bytes(buffer, generator, stdout).is_ok() {}
@@ -67,7 +42,7 @@ fn infinite_bytes_generation(
fn bytes_generation(
bytes_total: usize,
buffer: &mut [u8],
generator: &mut ActivatedRandomGenerator,
generator: &mut DefaultRandomGenerator,
stdout: &mut StdoutLock<'_>,
) {
let quotient = bytes_total / buffer.len();
@@ -120,7 +95,7 @@ pub fn main() {
let seed = seeder.seed();
// Don't print on std out
eprintln!("seed={seed:?}");
let mut generator = ActivatedRandomGenerator::new(seed);
let mut generator = DefaultRandomGenerator::new(seed);
let stdout = stdout();
let mut buffer = [0u8; 16];

5
tfhe-csprng/src/generators/aes_ctr/parallel.rs
View File

@@ -1,6 +1,5 @@
use crate::generators::aes_ctr::{
states::State, AesBlockCipher, AesCtrGenerator, ChildrenClosure, TableIndex,
};
use crate::generators::aes_ctr::states::State;
use crate::generators::aes_ctr::{AesBlockCipher, AesCtrGenerator, ChildrenClosure, TableIndex};
use crate::generators::{BytesPerChild, ChildrenCount, ForkError};
/// A type alias for the parallel children iterator type.

19
tfhe-csprng/src/generators/default.rs Normal file
View File

@@ -0,0 +1,19 @@
#[cfg(all(target_arch = "x86_64", not(feature = "software-prng")))]
use super::AesniRandomGenerator;
#[cfg(all(target_arch = "aarch64", not(feature = "software-prng")))]
use super::NeonAesRandomGenerator;
#[cfg(any(
feature = "software-prng",
not(any(target_arch = "x86_64", target_arch = "aarch64"))
))]
use super::SoftwareRandomGenerator;
#[cfg(all(target_arch = "x86_64", not(feature = "software-prng")))]
pub type DefaultRandomGenerator = AesniRandomGenerator;
#[cfg(all(target_arch = "aarch64", not(feature = "software-prng")))]
pub type DefaultRandomGenerator = NeonAesRandomGenerator;
#[cfg(any(
feature = "software-prng",
not(any(target_arch = "x86_64", target_arch = "aarch64"))
))]
pub type DefaultRandomGenerator = SoftwareRandomGenerator;

4
tfhe-csprng/src/generators/mod.rs
View File

@@ -123,6 +123,10 @@ mod aes_ctr;
mod implem;
pub use implem::*;
pub mod default;
/// Convenience alias for the most efficient CSPRNG implementation available.
pub use default::DefaultRandomGenerator;
#[cfg(test)]
#[allow(unused)] // to please clippy when tests are not activated
pub mod generator_generic_test {

4
tfhe/Cargo.toml
View File

@@ -53,7 +53,7 @@ strum = { version = "0.26", features = ["derive"] }
cbindgen = { version = "0.26.0", optional = true }
[dependencies]
tfhe-csprng = { version = "0.4.1", path = "../tfhe-csprng", features = ["parallel", "software-prng"] }
tfhe-csprng = { version = "0.4.1", path = "../tfhe-csprng", features = ["parallel"] }
serde = { workspace = true, features = ["default", "derive"] }
rayon = { workspace = true }
bincode = "1.3.3"
@@ -130,7 +130,7 @@ nightly-avx512 = ["tfhe-fft/nightly", "tfhe-ntt/nightly", "pulp/nightly"]
__profiling = []
__long_run_tests = []
software-prng = []
software-prng = ["tfhe-csprng/software-prng"]
# Cover several profiles as we cannot have a wildcard it seems
[package.metadata.wasm-pack.profile.dev.wasm-bindgen]

15
tfhe/benches/core_crypto/dev_bench.rs
View File

@@ -87,9 +87,8 @@ fn multi_bit_pbs<Scalar: UnsignedTorus + CastInto<usize> + CastFrom<usize> + Syn
let mut seeder = new_seeder();
let seeder = seeder.as_mut();
let mut encryption_generator =
EncryptionRandomGenerator::<ActivatedRandomGenerator>::new(seeder.seed(), seeder);
let mut secret_generator =
SecretRandomGenerator::<ActivatedRandomGenerator>::new(seeder.seed());
EncryptionRandomGenerator::<DefaultRandomGenerator>::new(seeder.seed(), seeder);
let mut secret_generator = SecretRandomGenerator::<DefaultRandomGenerator>::new(seeder.seed());
// Create the LweSecretKey
let input_lwe_secret_key =
@@ -180,9 +179,8 @@ fn pbs<Scalar: UnsignedTorus + CastInto<usize>>(c: &mut Criterion) {
let mut seeder = new_seeder();
let seeder = seeder.as_mut();
let mut encryption_generator =
EncryptionRandomGenerator::<ActivatedRandomGenerator>::new(seeder.seed(), seeder);
let mut secret_generator =
SecretRandomGenerator::<ActivatedRandomGenerator>::new(seeder.seed());
EncryptionRandomGenerator::<DefaultRandomGenerator>::new(seeder.seed(), seeder);
let mut secret_generator = SecretRandomGenerator::<DefaultRandomGenerator>::new(seeder.seed());
// Create the LweSecretKey
let input_lwe_secret_key =
@@ -270,9 +268,8 @@ fn mem_optimized_pbs<Scalar: UnsignedTorus + CastInto<usize>>(c: &mut Criterion)
let mut seeder = new_seeder();
let seeder = seeder.as_mut();
let mut encryption_generator =
EncryptionRandomGenerator::<ActivatedRandomGenerator>::new(seeder.seed(), seeder);
let mut secret_generator =
SecretRandomGenerator::<ActivatedRandomGenerator>::new(seeder.seed());
EncryptionRandomGenerator::<DefaultRandomGenerator>::new(seeder.seed(), seeder);
let mut secret_generator = SecretRandomGenerator::<DefaultRandomGenerator>::new(seeder.seed());
// Create the LweSecretKey
let input_lwe_secret_key =

18
tfhe/benches/core_crypto/ks_bench.rs
View File

@@ -130,9 +130,8 @@ fn keyswitch<Scalar: UnsignedTorus + CastInto<usize> + Serialize>(
let mut seeder = new_seeder();
let seeder = seeder.as_mut();
let mut encryption_generator =
EncryptionRandomGenerator::<ActivatedRandomGenerator>::new(seeder.seed(), seeder);
let mut secret_generator =
SecretRandomGenerator::<ActivatedRandomGenerator>::new(seeder.seed());
EncryptionRandomGenerator::<DefaultRandomGenerator>::new(seeder.seed(), seeder);
let mut secret_generator = SecretRandomGenerator::<DefaultRandomGenerator>::new(seeder.seed());
for (name, params) in parameters.iter() {
let lwe_dimension = params.lwe_dimension.unwrap();
@@ -216,9 +215,8 @@ fn packing_keyswitch<Scalar, F>(
let mut seeder = new_seeder();
let seeder = seeder.as_mut();
let mut encryption_generator =
EncryptionRandomGenerator::<ActivatedRandomGenerator>::new(seeder.seed(), seeder);
let mut secret_generator =
SecretRandomGenerator::<ActivatedRandomGenerator>::new(seeder.seed());
EncryptionRandomGenerator::<DefaultRandomGenerator>::new(seeder.seed(), seeder);
let mut secret_generator = SecretRandomGenerator::<DefaultRandomGenerator>::new(seeder.seed());
for (name, params) in parameters.iter() {
let lwe_dimension = params.lwe_dimension.unwrap();
@@ -325,9 +323,9 @@ mod cuda {
let mut seeder = new_seeder();
let seeder = seeder.as_mut();
let mut encryption_generator =
EncryptionRandomGenerator::<ActivatedRandomGenerator>::new(seeder.seed(), seeder);
EncryptionRandomGenerator::<DefaultRandomGenerator>::new(seeder.seed(), seeder);
let mut secret_generator =
SecretRandomGenerator::<ActivatedRandomGenerator>::new(seeder.seed());
SecretRandomGenerator::<DefaultRandomGenerator>::new(seeder.seed());
let gpu_index = 0;
let streams = CudaStreams::new_single_gpu(GpuIndex(gpu_index));
@@ -428,9 +426,9 @@ mod cuda {
let mut seeder = new_seeder();
let seeder = seeder.as_mut();
let mut encryption_generator =
EncryptionRandomGenerator::<ActivatedRandomGenerator>::new(seeder.seed(), seeder);
EncryptionRandomGenerator::<DefaultRandomGenerator>::new(seeder.seed(), seeder);
let mut secret_generator =
SecretRandomGenerator::<ActivatedRandomGenerator>::new(seeder.seed());
SecretRandomGenerator::<DefaultRandomGenerator>::new(seeder.seed());
let gpu_index = 0;
let streams = CudaStreams::new_single_gpu(GpuIndex(gpu_index));

5
tfhe/benches/core_crypto/pbs128_bench.rs
View File

@@ -34,11 +34,10 @@ fn pbs_128(c: &mut Criterion) {
let mut boxed_seeder = new_seeder();
let seeder = boxed_seeder.as_mut();
let mut secret_generator =
SecretRandomGenerator::<ActivatedRandomGenerator>::new(seeder.seed());
let mut secret_generator = SecretRandomGenerator::<DefaultRandomGenerator>::new(seeder.seed());
let mut encryption_generator =
EncryptionRandomGenerator::<ActivatedRandomGenerator>::new(seeder.seed(), seeder);
EncryptionRandomGenerator::<DefaultRandomGenerator>::new(seeder.seed(), seeder);
let input_lwe_secret_key =
LweSecretKey::generate_new_binary(lwe_dimension, &mut secret_generator);

46
tfhe/benches/core_crypto/pbs_bench.rs
View File

@@ -139,9 +139,8 @@ fn mem_optimized_pbs<Scalar: UnsignedTorus + CastInto<usize> + Serialize>(
let mut seeder = new_seeder();
let seeder = seeder.as_mut();
let mut encryption_generator =
EncryptionRandomGenerator::<ActivatedRandomGenerator>::new(seeder.seed(), seeder);
let mut secret_generator =
SecretRandomGenerator::<ActivatedRandomGenerator>::new(seeder.seed());
EncryptionRandomGenerator::<DefaultRandomGenerator>::new(seeder.seed(), seeder);
let mut secret_generator = SecretRandomGenerator::<DefaultRandomGenerator>::new(seeder.seed());
for (name, params) in parameters.iter() {
// Create the LweSecretKey
@@ -248,9 +247,8 @@ fn mem_optimized_batched_pbs<Scalar: UnsignedTorus + CastInto<usize> + Serialize
let mut seeder = new_seeder();
let seeder = seeder.as_mut();
let mut encryption_generator =
EncryptionRandomGenerator::<ActivatedRandomGenerator>::new(seeder.seed(), seeder);
let mut secret_generator =
SecretRandomGenerator::<ActivatedRandomGenerator>::new(seeder.seed());
EncryptionRandomGenerator::<DefaultRandomGenerator>::new(seeder.seed(), seeder);
let mut secret_generator = SecretRandomGenerator::<DefaultRandomGenerator>::new(seeder.seed());
for (name, params) in parameters.iter() {
// Create the LweSecretKey
@@ -371,9 +369,8 @@ fn multi_bit_pbs<
let mut seeder = new_seeder();
let seeder = seeder.as_mut();
let mut encryption_generator =
EncryptionRandomGenerator::<ActivatedRandomGenerator>::new(seeder.seed(), seeder);
let mut secret_generator =
SecretRandomGenerator::<ActivatedRandomGenerator>::new(seeder.seed());
EncryptionRandomGenerator::<DefaultRandomGenerator>::new(seeder.seed(), seeder);
let mut secret_generator = SecretRandomGenerator::<DefaultRandomGenerator>::new(seeder.seed());
for (name, params, grouping_factor) in parameters.iter() {
// Create the LweSecretKey
@@ -465,9 +462,8 @@ fn multi_bit_deterministic_pbs<
let mut seeder = new_seeder();
let seeder = seeder.as_mut();
let mut encryption_generator =
EncryptionRandomGenerator::<ActivatedRandomGenerator>::new(seeder.seed(), seeder);
let mut secret_generator =
SecretRandomGenerator::<ActivatedRandomGenerator>::new(seeder.seed());
EncryptionRandomGenerator::<DefaultRandomGenerator>::new(seeder.seed(), seeder);
let mut secret_generator = SecretRandomGenerator::<DefaultRandomGenerator>::new(seeder.seed());
for (name, params, grouping_factor) in parameters.iter() {
// Create the LweSecretKey
@@ -554,9 +550,8 @@ fn mem_optimized_pbs_ntt(c: &mut Criterion) {
let mut seeder = new_seeder();
let seeder = seeder.as_mut();
let mut encryption_generator =
EncryptionRandomGenerator::<ActivatedRandomGenerator>::new(seeder.seed(), seeder);
let mut secret_generator =
SecretRandomGenerator::<ActivatedRandomGenerator>::new(seeder.seed());
EncryptionRandomGenerator::<DefaultRandomGenerator>::new(seeder.seed(), seeder);
let mut secret_generator = SecretRandomGenerator::<DefaultRandomGenerator>::new(seeder.seed());
let custom_ciphertext_modulus =
tfhe::core_crypto::prelude::CiphertextModulus::new((1 << 64) - (1 << 32) + 1);
@@ -709,9 +704,8 @@ fn pbs_throughput<Scalar: UnsignedTorus + CastInto<usize> + Sync + Send + Serial
let mut seeder = new_seeder();
let seeder = seeder.as_mut();
let mut encryption_generator =
EncryptionRandomGenerator::<ActivatedRandomGenerator>::new(seeder.seed(), seeder);
let mut secret_generator =
SecretRandomGenerator::<ActivatedRandomGenerator>::new(seeder.seed());
EncryptionRandomGenerator::<DefaultRandomGenerator>::new(seeder.seed(), seeder);
let mut secret_generator = SecretRandomGenerator::<DefaultRandomGenerator>::new(seeder.seed());
for (name, params) in parameters.iter() {
let input_lwe_secret_key = allocate_and_generate_new_binary_lwe_secret_key(
@@ -895,9 +889,9 @@ mod cuda {
let mut seeder = new_seeder();
let seeder = seeder.as_mut();
let mut encryption_generator =
EncryptionRandomGenerator::<ActivatedRandomGenerator>::new(seeder.seed(), seeder);
EncryptionRandomGenerator::<DefaultRandomGenerator>::new(seeder.seed(), seeder);
let mut secret_generator =
SecretRandomGenerator::<ActivatedRandomGenerator>::new(seeder.seed());
SecretRandomGenerator::<DefaultRandomGenerator>::new(seeder.seed());
let gpu_index = 0;
let stream = CudaStreams::new_single_gpu(GpuIndex(gpu_index));
@@ -1016,9 +1010,9 @@ mod cuda {
let mut seeder = new_seeder();
let seeder = seeder.as_mut();
let mut encryption_generator =
EncryptionRandomGenerator::<ActivatedRandomGenerator>::new(seeder.seed(), seeder);
EncryptionRandomGenerator::<DefaultRandomGenerator>::new(seeder.seed(), seeder);
let mut secret_generator =
SecretRandomGenerator::<ActivatedRandomGenerator>::new(seeder.seed());
SecretRandomGenerator::<DefaultRandomGenerator>::new(seeder.seed());
let gpu_index = 0;
let stream = CudaStreams::new_single_gpu(GpuIndex(gpu_index));
@@ -1138,9 +1132,9 @@ mod cuda {
let mut seeder = new_seeder();
let seeder = seeder.as_mut();
let mut encryption_generator =
EncryptionRandomGenerator::<ActivatedRandomGenerator>::new(seeder.seed(), seeder);
EncryptionRandomGenerator::<DefaultRandomGenerator>::new(seeder.seed(), seeder);
let mut secret_generator =
SecretRandomGenerator::<ActivatedRandomGenerator>::new(seeder.seed());
SecretRandomGenerator::<DefaultRandomGenerator>::new(seeder.seed());
let gpu_index = 0;
let stream = CudaStreams::new_single_gpu(GpuIndex(gpu_index));
@@ -1278,9 +1272,9 @@ mod cuda {
let mut seeder = new_seeder();
let seeder = seeder.as_mut();
let mut encryption_generator =
EncryptionRandomGenerator::<ActivatedRandomGenerator>::new(seeder.seed(), seeder);
EncryptionRandomGenerator::<DefaultRandomGenerator>::new(seeder.seed(), seeder);
let mut secret_generator =
SecretRandomGenerator::<ActivatedRandomGenerator>::new(seeder.seed());
SecretRandomGenerator::<DefaultRandomGenerator>::new(seeder.seed());
let gpu_index = 0;
let stream = CudaStreams::new_single_gpu(GpuIndex(gpu_index));

8
tfhe/benches/keygen/bench.rs
View File

@@ -2,7 +2,7 @@ use criterion::*;
use tfhe::core_crypto::commons::generators::DeterministicSeeder;
use tfhe::core_crypto::prelude::{
allocate_and_generate_new_binary_glwe_secret_key,
par_allocate_and_generate_new_lwe_bootstrap_key, ActivatedRandomGenerator, CiphertextModulus,
par_allocate_and_generate_new_lwe_bootstrap_key, CiphertextModulus, DefaultRandomGenerator,
EncryptionRandomGenerator, SecretRandomGenerator,
};
use tfhe::core_crypto::seeders::new_seeder;
@@ -13,10 +13,10 @@ fn criterion_bench(c: &mut Criterion) {
let parameters = PARAM_MESSAGE_2_CARRY_2_KS_PBS;
let mut seeder = new_seeder();
let mut deterministic_seeder =
DeterministicSeeder::<ActivatedRandomGenerator>::new(seeder.seed());
DeterministicSeeder::<DefaultRandomGenerator>::new(seeder.seed());
let mut secret_generator =
SecretRandomGenerator::<ActivatedRandomGenerator>::new(deterministic_seeder.seed());
let mut encryption_generator = EncryptionRandomGenerator::<ActivatedRandomGenerator>::new(
SecretRandomGenerator::<DefaultRandomGenerator>::new(deterministic_seeder.seed());
let mut encryption_generator = EncryptionRandomGenerator::<DefaultRandomGenerator>::new(
deterministic_seeder.seed(),
&mut deterministic_seeder,
);

4
tfhe/docs/references/core-crypto-api/presentation.md
View File

@@ -25,9 +25,9 @@ let ciphertext_modulus = CiphertextModulus::new_native();
let mut seeder = new_seeder();
let seeder = seeder.as_mut();
let mut encryption_generator =
EncryptionRandomGenerator::<ActivatedRandomGenerator>::new(seeder.seed(), seeder);
EncryptionRandomGenerator::<DefaultRandomGenerator>::new(seeder.seed(), seeder);
let mut secret_generator =
SecretRandomGenerator::<ActivatedRandomGenerator>::new(seeder.seed());
SecretRandomGenerator::<DefaultRandomGenerator>::new(seeder.seed());
// Create the LweSecretKey
let lwe_secret_key =

4
tfhe/docs/references/core-crypto-api/tutorial.md
View File

@@ -42,12 +42,12 @@ pub fn main() {
// Create a generator which uses a CSPRNG to generate secret keys
let mut secret_generator =
SecretRandomGenerator::<ActivatedRandomGenerator>::new(seeder.seed());
SecretRandomGenerator::<DefaultRandomGenerator>::new(seeder.seed());
// Create a generator which uses two CSPRNGs to generate public masks and secret encryption
// noise
let mut encryption_generator =
EncryptionRandomGenerator::<ActivatedRandomGenerator>::new(seeder.seed(), seeder);
EncryptionRandomGenerator::<DefaultRandomGenerator>::new(seeder.seed(), seeder);
println!("Generating keys...");

10
tfhe/src/boolean/engine/bootstrapping.rs
View File

@@ -6,7 +6,7 @@ use crate::boolean::{ClientKey, PLAINTEXT_TRUE};
use crate::core_crypto::algorithms::*;
use crate::core_crypto::commons::computation_buffers::ComputationBuffers;
use crate::core_crypto::commons::generators::{DeterministicSeeder, EncryptionRandomGenerator};
use crate::core_crypto::commons::math::random::{ActivatedRandomGenerator, Seeder};
use crate::core_crypto::commons::math::random::{DefaultRandomGenerator, Seeder};
use crate::core_crypto::commons::parameters::{CiphertextModulus, PBSOrder};
use crate::core_crypto::entities::*;
use crate::core_crypto::fft_impl::fft64::math::fft::Fft;
@@ -214,7 +214,7 @@ impl CompressedServerKey {
compressed_key_switching_key.output_key_lwe_dimension(),
compressed_key_switching_key.ciphertext_modulus(),
);
par_decompress_seeded_lwe_keyswitch_key::<_, _, _, ActivatedRandomGenerator>(
par_decompress_seeded_lwe_keyswitch_key::<_, _, _, DefaultRandomGenerator>(
&mut decompressed_key_switching_key,
compressed_key_switching_key,
);
@@ -230,7 +230,7 @@ impl CompressedServerKey {
compressed_bootstrapping_key.input_lwe_dimension(),
compressed_bootstrapping_key.ciphertext_modulus(),
);
par_decompress_seeded_lwe_bootstrap_key::<_, _, _, ActivatedRandomGenerator>(
par_decompress_seeded_lwe_bootstrap_key::<_, _, _, DefaultRandomGenerator>(
&mut decompressed_bootstrapping_key,
compressed_bootstrapping_key,
);
@@ -331,9 +331,9 @@ pub(crate) struct Bootstrapper {
/// The [`EncryptionRandomGenerator`] contains two CSPRNGs, one publicly seeded used to
/// generate mask coefficients and one privately seeded used to generate errors during
/// encryption.
pub(crate) encryption_generator: EncryptionRandomGenerator<ActivatedRandomGenerator>,
pub(crate) encryption_generator: EncryptionRandomGenerator<DefaultRandomGenerator>,
pub(crate) computation_buffers: ComputationBuffers,
pub(crate) seeder: DeterministicSeeder<ActivatedRandomGenerator>,
pub(crate) seeder: DeterministicSeeder<DefaultRandomGenerator>,
}
impl Bootstrapper {

12
tfhe/src/boolean/engine/mod.rs
View File

@@ -11,7 +11,7 @@ use crate::core_crypto::algorithms::*;
use crate::core_crypto::commons::generators::{
DeterministicSeeder, EncryptionRandomGenerator, SecretRandomGenerator,
};
use crate::core_crypto::commons::math::random::{ActivatedRandomGenerator, Seeder};
use crate::core_crypto::commons::math::random::{DefaultRandomGenerator, Seeder};
use crate::core_crypto::commons::parameters::*;
use crate::core_crypto::entities::*;
use crate::core_crypto::seeders::new_seeder;
@@ -56,14 +56,14 @@ thread_local! {
pub struct BooleanEngine {
/// A structure containing a single CSPRNG to generate secret key coefficients.
secret_generator: SecretRandomGenerator<ActivatedRandomGenerator>,
secret_generator: SecretRandomGenerator<DefaultRandomGenerator>,
/// A structure containing two CSPRNGs to generate material for encryption like public masks
/// and secret errors.
///
/// The [`EncryptionRandomGenerator`] contains two CSPRNGs, one publicly seeded used to
/// generate mask coefficients and one privately seeded used to generate errors during
/// encryption.
encryption_generator: EncryptionRandomGenerator<ActivatedRandomGenerator>,
encryption_generator: EncryptionRandomGenerator<DefaultRandomGenerator>,
bootstrapper: Bootstrapper,
}
@@ -366,14 +366,14 @@ impl BooleanEngine {
/// use tfhe::boolean::engine::BooleanEngine;
/// use tfhe::core_crypto::commons::generators::DeterministicSeeder;
/// use tfhe::core_crypto::commons::math::random::Seed;
/// use tfhe::core_crypto::prelude::ActivatedRandomGenerator;
/// use tfhe::core_crypto::prelude::DefaultRandomGenerator;
///
/// // WARNING: Using a deterministic seed is not recommended
/// // as it renders the random generation insecure
///
/// let deterministic_seed = Seed(0);
///
/// let mut seeder = DeterministicSeeder::<ActivatedRandomGenerator>::new(deterministic_seed);
/// let mut seeder = DeterministicSeeder::<DefaultRandomGenerator>::new(deterministic_seed);
/// let boolean_engine = BooleanEngine::new_from_seeder(&mut seeder);
/// BooleanEngine::replace_thread_local(boolean_engine);
///
@@ -394,7 +394,7 @@ impl BooleanEngine {
pub fn new_from_seeder(root_seeder: &mut dyn Seeder) -> Self {
let mut deterministic_seeder =
DeterministicSeeder::<ActivatedRandomGenerator>::new(root_seeder.seed());
DeterministicSeeder::<DefaultRandomGenerator>::new(root_seeder.seed());
// Note that the operands are evaluated from left to right for Rust Struct expressions
// See: https://doc.rust-lang.org/stable/reference/expressions.html?highlight=left#evaluation-order-of-operands

6
tfhe/src/boolean/engine/tests.rs
View File

@@ -3,7 +3,7 @@ fn test_replacing_thread_local_engine() {
use crate::boolean::engine::BooleanEngine;
use crate::core_crypto::commons::generators::DeterministicSeeder;
use crate::core_crypto::commons::math::random::Seed;
use crate::core_crypto::prelude::ActivatedRandomGenerator;
use crate::core_crypto::prelude::DefaultRandomGenerator;
let deterministic_seed = Seed(0);
@@ -11,7 +11,7 @@ fn test_replacing_thread_local_engine() {
// then generate a client key, and then encrypt
// a boolean value and serialize it to compare
// it with other ciphertext
let mut seeder = DeterministicSeeder::<ActivatedRandomGenerator>::new(deterministic_seed);
let mut seeder = DeterministicSeeder::<DefaultRandomGenerator>::new(deterministic_seed);
let boolean_engine = BooleanEngine::new_from_seeder(&mut seeder);
BooleanEngine::replace_thread_local(boolean_engine);
@@ -41,7 +41,7 @@ fn test_replacing_thread_local_engine() {
// So we expect the encrypted value to be the same
// compared with the one from the main thread
let third_thread_data = std::thread::spawn(move || {
let mut seeder = DeterministicSeeder::<ActivatedRandomGenerator>::new(deterministic_seed);
let mut seeder = DeterministicSeeder::<DefaultRandomGenerator>::new(deterministic_seed);
let boolean_engine = BooleanEngine::new_from_seeder(&mut seeder);
BooleanEngine::replace_thread_local(boolean_engine);
let (cks, _) = crate::boolean::gen_keys();

27
tfhe/src/c_api/core_crypto/mod.rs
View File

@@ -135,8 +135,7 @@ pub unsafe extern "C" fn core_crypto_lwe_secret_key(
let seed_high_bytes: u128 = seed_high_bytes.into();
let seed = (seed_high_bytes << 64) | seed_low_bytes;
let mut secret_generator =
SecretRandomGenerator::<ActivatedRandomGenerator>::new(Seed(seed));
let mut secret_generator = SecretRandomGenerator::<DefaultRandomGenerator>::new(Seed(seed));
// Create the LweSecretKey
let output_lwe_sk_slice = std::slice::from_raw_parts_mut(output_lwe_sk_ptr, lwe_sk_dim);
@@ -170,8 +169,8 @@ pub unsafe extern "C" fn core_crypto_lwe_encrypt(
let seed = (seed_high_bytes << 64) | seed_low_bytes;
let seed = Seed(seed);
let mut deterministic_seeder = DeterministicSeeder::<ActivatedRandomGenerator>::new(seed);
let mut encryption_generator = EncryptionRandomGenerator::<ActivatedRandomGenerator>::new(
let mut deterministic_seeder = DeterministicSeeder::<DefaultRandomGenerator>::new(seed);
let mut encryption_generator = EncryptionRandomGenerator::<DefaultRandomGenerator>::new(
deterministic_seeder.seed(),
&mut deterministic_seeder,
);
@@ -219,8 +218,8 @@ pub unsafe extern "C" fn core_crypto_ggsw_encrypt(
let seed = (seed_high_bytes << 64) | seed_low_bytes;
let seed = Seed(seed);
let mut deterministic_seeder = DeterministicSeeder::<ActivatedRandomGenerator>::new(seed);
let mut encryption_generator = EncryptionRandomGenerator::<ActivatedRandomGenerator>::new(
let mut deterministic_seeder = DeterministicSeeder::<DefaultRandomGenerator>::new(seed);
let mut encryption_generator = EncryptionRandomGenerator::<DefaultRandomGenerator>::new(
deterministic_seeder.seed(),
&mut deterministic_seeder,
);
@@ -379,9 +378,9 @@ pub unsafe extern "C" fn core_crypto_par_generate_lwe_bootstrapping_key(
let seed = (seed_high_bytes << 64) | seed_low_bytes;
let mut deterministic_seeder =
DeterministicSeeder::<ActivatedRandomGenerator>::new(Seed(seed));
DeterministicSeeder::<DefaultRandomGenerator>::new(Seed(seed));
let mut encryption_random_generator =
EncryptionRandomGenerator::<ActivatedRandomGenerator>::new(
EncryptionRandomGenerator::<DefaultRandomGenerator>::new(
deterministic_seeder.seed(),
&mut deterministic_seeder,
);
@@ -463,9 +462,9 @@ pub unsafe extern "C" fn core_crypto_par_generate_lwe_multi_bit_bootstrapping_ke
let seed = (seed_high_bytes << 64) | seed_low_bytes;
let mut deterministic_seeder =
DeterministicSeeder::<ActivatedRandomGenerator>::new(Seed(seed));
DeterministicSeeder::<DefaultRandomGenerator>::new(Seed(seed));
let mut encryption_random_generator =
EncryptionRandomGenerator::<ActivatedRandomGenerator>::new(
EncryptionRandomGenerator::<DefaultRandomGenerator>::new(
deterministic_seeder.seed(),
&mut deterministic_seeder,
);
@@ -542,9 +541,9 @@ pub unsafe extern "C" fn core_crypto_par_generate_lwe_keyswitch_key(
let seed = (seed_high_bytes << 64) | seed_low_bytes;
let mut deterministic_seeder =
DeterministicSeeder::<ActivatedRandomGenerator>::new(Seed(seed));
DeterministicSeeder::<DefaultRandomGenerator>::new(Seed(seed));
let mut encryption_random_generator =
EncryptionRandomGenerator::<ActivatedRandomGenerator>::new(
EncryptionRandomGenerator::<DefaultRandomGenerator>::new(
deterministic_seeder.seed(),
&mut deterministic_seeder,
);
@@ -618,9 +617,9 @@ pub unsafe extern "C" fn core_crypto_par_generate_lwe_private_functional_keyswit
let seed = (seed_high_bytes << 64) | seed_low_bytes;
let mut deterministic_seeder =
DeterministicSeeder::<ActivatedRandomGenerator>::new(Seed(seed));
DeterministicSeeder::<DefaultRandomGenerator>::new(Seed(seed));
let mut encryption_random_generator =
EncryptionRandomGenerator::<ActivatedRandomGenerator>::new(
EncryptionRandomGenerator::<DefaultRandomGenerator>::new(
deterministic_seeder.seed(),
&mut deterministic_seeder,
);

27
tfhe/src/core_crypto/algorithms/ggsw_encryption.rs
View File

@@ -9,7 +9,7 @@ use crate::core_crypto::commons::generators::EncryptionRandomGenerator;
use crate::core_crypto::commons::math::decomposition::{
DecompositionLevel, DecompositionTerm, DecompositionTermNonNative, SignedDecomposer,
};
use crate::core_crypto::commons::math::random::{ActivatedRandomGenerator, Distribution, Uniform};
use crate::core_crypto::commons::math::random::{DefaultRandomGenerator, Distribution, Uniform};
use crate::core_crypto::commons::parameters::{DecompositionBaseLog, PlaintextCount};
use crate::core_crypto::commons::traits::*;
use crate::core_crypto::entities::*;
@@ -66,9 +66,8 @@ pub fn ggsw_encryption_multiplicative_factor<Scalar: UnsignedInteger>(
/// let mut seeder = new_seeder();
/// let seeder = seeder.as_mut();
/// let mut encryption_generator =
/// EncryptionRandomGenerator::<ActivatedRandomGenerator>::new(seeder.seed(), seeder);
/// let mut secret_generator =
/// SecretRandomGenerator::<ActivatedRandomGenerator>::new(seeder.seed());
/// EncryptionRandomGenerator::<DefaultRandomGenerator>::new(seeder.seed(), seeder);
/// let mut secret_generator = SecretRandomGenerator::<DefaultRandomGenerator>::new(seeder.seed());
///
/// // Create the GlweSecretKey
/// let glwe_secret_key = allocate_and_generate_new_binary_glwe_secret_key(
@@ -200,9 +199,8 @@ pub fn encrypt_constant_ggsw_ciphertext<Scalar, NoiseDistribution, KeyCont, Outp
/// let mut seeder = new_seeder();
/// let seeder = seeder.as_mut();
/// let mut encryption_generator =
/// EncryptionRandomGenerator::<ActivatedRandomGenerator>::new(seeder.seed(), seeder);
/// let mut secret_generator =
/// SecretRandomGenerator::<ActivatedRandomGenerator>::new(seeder.seed());
/// EncryptionRandomGenerator::<DefaultRandomGenerator>::new(seeder.seed(), seeder);
/// let mut secret_generator = SecretRandomGenerator::<DefaultRandomGenerator>::new(seeder.seed());
///
/// // Create the GlweSecretKey
/// let glwe_secret_key = allocate_and_generate_new_binary_glwe_secret_key(
@@ -465,8 +463,7 @@ pub fn encrypt_constant_seeded_ggsw_ciphertext_with_existing_generator<
/// // Create the PRNG
/// let mut seeder = new_seeder();
/// let seeder = seeder.as_mut();
/// let mut secret_generator =
/// SecretRandomGenerator::<ActivatedRandomGenerator>::new(seeder.seed());
/// let mut secret_generator = SecretRandomGenerator::<DefaultRandomGenerator>::new(seeder.seed());
///
/// // Create the GlweSecretKey
/// let glwe_secret_key = allocate_and_generate_new_binary_glwe_secret_key(
@@ -538,7 +535,7 @@ pub fn encrypt_constant_seeded_ggsw_ciphertext<
glwe_secret_key.glwe_dimension()
);
let mut generator = EncryptionRandomGenerator::<ActivatedRandomGenerator>::new(
let mut generator = EncryptionRandomGenerator::<DefaultRandomGenerator>::new(
output.compression_seed().seed,
noise_seeder,
);
@@ -649,8 +646,7 @@ pub fn par_encrypt_constant_seeded_ggsw_ciphertext_with_existing_generator<
/// // Create the PRNG
/// let mut seeder = new_seeder();
/// let seeder = seeder.as_mut();
/// let mut secret_generator =
/// SecretRandomGenerator::<ActivatedRandomGenerator>::new(seeder.seed());
/// let mut secret_generator = SecretRandomGenerator::<DefaultRandomGenerator>::new(seeder.seed());
///
/// // Create the GlweSecretKey
/// let glwe_secret_key = allocate_and_generate_new_binary_glwe_secret_key(
@@ -717,7 +713,7 @@ pub fn par_encrypt_constant_seeded_ggsw_ciphertext<
glwe_secret_key.glwe_dimension()
);
let mut generator = EncryptionRandomGenerator::<ActivatedRandomGenerator>::new(
let mut generator = EncryptionRandomGenerator::<DefaultRandomGenerator>::new(
output.compression_seed().seed,
noise_seeder,
);
@@ -825,9 +821,8 @@ fn encrypt_constant_seeded_ggsw_level_matrix_row<
/// let mut seeder = new_seeder();
/// let seeder = seeder.as_mut();
/// let mut encryption_generator =
/// EncryptionRandomGenerator::<ActivatedRandomGenerator>::new(seeder.seed(), seeder);
/// let mut secret_generator =
/// SecretRandomGenerator::<ActivatedRandomGenerator>::new(seeder.seed());
/// EncryptionRandomGenerator::<DefaultRandomGenerator>::new(seeder.seed(), seeder);
/// let mut secret_generator = SecretRandomGenerator::<DefaultRandomGenerator>::new(seeder.seed());
///
/// // Create the GlweSecretKey
/// let glwe_secret_key = allocate_and_generate_new_binary_glwe_secret_key(

33
tfhe/src/core_crypto/algorithms/glwe_encryption.rs
View File

@@ -7,7 +7,7 @@ use crate::core_crypto::algorithms::slice_algorithms::{
};
use crate::core_crypto::commons::ciphertext_modulus::CiphertextModulusKind;
use crate::core_crypto::commons::generators::EncryptionRandomGenerator;
use crate::core_crypto::commons::math::random::{ActivatedRandomGenerator, Distribution, Uniform};
use crate::core_crypto::commons::math::random::{DefaultRandomGenerator, Distribution, Uniform};
use crate::core_crypto::commons::parameters::*;
use crate::core_crypto::commons::traits::*;
use crate::core_crypto::entities::*;
@@ -184,9 +184,8 @@ pub fn fill_glwe_mask_and_body_for_encryption_assign_non_native_mod<
/// let mut seeder = new_seeder();
/// let seeder = seeder.as_mut();
/// let mut encryption_generator =
/// EncryptionRandomGenerator::<ActivatedRandomGenerator>::new(seeder.seed(), seeder);
/// let mut secret_generator =
/// SecretRandomGenerator::<ActivatedRandomGenerator>::new(seeder.seed());
/// EncryptionRandomGenerator::<DefaultRandomGenerator>::new(seeder.seed(), seeder);
/// let mut secret_generator = SecretRandomGenerator::<DefaultRandomGenerator>::new(seeder.seed());
///
/// // Create the GlweSecretKey
/// let glwe_secret_key = allocate_and_generate_new_binary_glwe_secret_key(
@@ -522,9 +521,8 @@ pub fn fill_glwe_mask_and_body_for_encryption_other_mod<
/// let mut seeder = new_seeder();
/// let seeder = seeder.as_mut();
/// let mut encryption_generator =
/// EncryptionRandomGenerator::<ActivatedRandomGenerator>::new(seeder.seed(), seeder);
/// let mut secret_generator =
/// SecretRandomGenerator::<ActivatedRandomGenerator>::new(seeder.seed());
/// EncryptionRandomGenerator::<DefaultRandomGenerator>::new(seeder.seed(), seeder);
/// let mut secret_generator = SecretRandomGenerator::<DefaultRandomGenerator>::new(seeder.seed());
///
/// // Create the GlweSecretKey
/// let glwe_secret_key = allocate_and_generate_new_binary_glwe_secret_key(
@@ -644,9 +642,8 @@ pub fn encrypt_glwe_ciphertext<Scalar, NoiseDistribution, KeyCont, InputCont, Ou
/// let mut seeder = new_seeder();
/// let seeder = seeder.as_mut();
/// let mut encryption_generator =
/// EncryptionRandomGenerator::<ActivatedRandomGenerator>::new(seeder.seed(), seeder);
/// let mut secret_generator =
/// SecretRandomGenerator::<ActivatedRandomGenerator>::new(seeder.seed());
/// EncryptionRandomGenerator::<DefaultRandomGenerator>::new(seeder.seed(), seeder);
/// let mut secret_generator = SecretRandomGenerator::<DefaultRandomGenerator>::new(seeder.seed());
///
/// // Create the GlweSecretKey
/// let glwe_secret_key = allocate_and_generate_new_binary_glwe_secret_key(
@@ -972,8 +969,7 @@ pub fn decrypt_glwe_ciphertext_list<Scalar, KeyCont, InputCont, OutputCont>(
/// // Create the PRNG
/// let mut seeder = new_seeder();
/// let seeder = seeder.as_mut();
/// let mut secret_generator =
/// SecretRandomGenerator::<ActivatedRandomGenerator>::new(seeder.seed());
/// let mut secret_generator = SecretRandomGenerator::<DefaultRandomGenerator>::new(seeder.seed());
///
/// // Create the plaintext
/// let msg = 3u64;
@@ -1067,8 +1063,7 @@ pub fn trivially_encrypt_glwe_ciphertext<Scalar, InputCont, OutputCont>(
/// // Create the PRNG
/// let mut seeder = new_seeder();
/// let seeder = seeder.as_mut();
/// let mut secret_generator =
/// SecretRandomGenerator::<ActivatedRandomGenerator>::new(seeder.seed());
/// let mut secret_generator = SecretRandomGenerator::<DefaultRandomGenerator>::new(seeder.seed());
///
/// // Create the plaintext
/// let msg = 3u64;
@@ -1217,8 +1212,7 @@ pub fn encrypt_seeded_glwe_ciphertext_with_existing_generator<
/// // Create the PRNG
/// let mut seeder = new_seeder();
/// let seeder = seeder.as_mut();
/// let mut secret_generator =
/// SecretRandomGenerator::<ActivatedRandomGenerator>::new(seeder.seed());
/// let mut secret_generator = SecretRandomGenerator::<DefaultRandomGenerator>::new(seeder.seed());
///
/// // Create the GlweSecretKey
/// let glwe_secret_key = allocate_and_generate_new_binary_glwe_secret_key(
@@ -1295,7 +1289,7 @@ pub fn encrypt_seeded_glwe_ciphertext<
// Maybe Sized allows to pass Box<dyn Seeder>.
NoiseSeeder: Seeder + ?Sized,
{
let mut generator = EncryptionRandomGenerator::<ActivatedRandomGenerator>::new(
let mut generator = EncryptionRandomGenerator::<DefaultRandomGenerator>::new(
output_glwe_ciphertext.compression_seed().seed,
noise_seeder,
);
@@ -1404,8 +1398,7 @@ pub fn encrypt_seeded_glwe_ciphertext_list_with_existing_generator<
/// // Create the PRNG
/// let mut seeder = new_seeder();
/// let seeder = seeder.as_mut();
/// let mut secret_generator =
/// SecretRandomGenerator::<ActivatedRandomGenerator>::new(seeder.seed());
/// let mut secret_generator = SecretRandomGenerator::<DefaultRandomGenerator>::new(seeder.seed());
///
/// // Create the GlweSecretKey
/// let glwe_secret_key = allocate_and_generate_new_binary_glwe_secret_key(
@@ -1486,7 +1479,7 @@ pub fn encrypt_seeded_glwe_ciphertext_list<
// Maybe Sized allows to pass Box<dyn Seeder>.
NoiseSeeder: Seeder + ?Sized,
{
let mut generator = EncryptionRandomGenerator::<ActivatedRandomGenerator>::new(
let mut generator = EncryptionRandomGenerator::<DefaultRandomGenerator>::new(
output.compression_seed().seed,
noise_seeder,
);

55
tfhe/src/core_crypto/algorithms/glwe_linear_algebra.rs
View File

@@ -26,9 +26,8 @@ use crate::core_crypto::entities::*;
/// let mut seeder = new_seeder();
/// let seeder = seeder.as_mut();
/// let mut encryption_generator =
/// EncryptionRandomGenerator::<ActivatedRandomGenerator>::new(seeder.seed(), seeder);
/// let mut secret_generator =
/// SecretRandomGenerator::<ActivatedRandomGenerator>::new(seeder.seed());
/// EncryptionRandomGenerator::<DefaultRandomGenerator>::new(seeder.seed(), seeder);
/// let mut secret_generator = SecretRandomGenerator::<DefaultRandomGenerator>::new(seeder.seed());
///
/// // Create the GlweSecretKey
/// let glwe_secret_key = allocate_and_generate_new_binary_glwe_secret_key(
@@ -119,9 +118,8 @@ pub fn glwe_ciphertext_add_assign<Scalar, LhsCont, RhsCont>(
/// let mut seeder = new_seeder();
/// let seeder = seeder.as_mut();
/// let mut encryption_generator =
/// EncryptionRandomGenerator::<ActivatedRandomGenerator>::new(seeder.seed(), seeder);
/// let mut secret_generator =
/// SecretRandomGenerator::<ActivatedRandomGenerator>::new(seeder.seed());
/// EncryptionRandomGenerator::<DefaultRandomGenerator>::new(seeder.seed(), seeder);
/// let mut secret_generator = SecretRandomGenerator::<DefaultRandomGenerator>::new(seeder.seed());
///
/// // Create the GlweSecretKey
/// let glwe_secret_key = allocate_and_generate_new_binary_glwe_secret_key(
@@ -223,9 +221,8 @@ pub fn glwe_ciphertext_add<Scalar, OutputCont, LhsCont, RhsCont>(
/// let mut seeder = new_seeder();
/// let seeder = seeder.as_mut();
/// let mut encryption_generator =
/// EncryptionRandomGenerator::<ActivatedRandomGenerator>::new(seeder.seed(), seeder);
/// let mut secret_generator =
/// SecretRandomGenerator::<ActivatedRandomGenerator>::new(seeder.seed());
/// EncryptionRandomGenerator::<DefaultRandomGenerator>::new(seeder.seed(), seeder);
/// let mut secret_generator = SecretRandomGenerator::<DefaultRandomGenerator>::new(seeder.seed());
///
/// // Create the GlweSecretKey
/// let glwe_secret_key = allocate_and_generate_new_binary_glwe_secret_key(
@@ -315,9 +312,8 @@ pub fn glwe_ciphertext_plaintext_list_add_assign<Scalar, InCont, PlainCont>(
/// let mut seeder = new_seeder();
/// let seeder = seeder.as_mut();
/// let mut encryption_generator =
/// EncryptionRandomGenerator::<ActivatedRandomGenerator>::new(seeder.seed(), seeder);
/// let mut secret_generator =
/// SecretRandomGenerator::<ActivatedRandomGenerator>::new(seeder.seed());
/// EncryptionRandomGenerator::<DefaultRandomGenerator>::new(seeder.seed(), seeder);
/// let mut secret_generator = SecretRandomGenerator::<DefaultRandomGenerator>::new(seeder.seed());
///
/// // Create the GlweSecretKey
/// let glwe_secret_key = allocate_and_generate_new_binary_glwe_secret_key(
@@ -407,9 +403,8 @@ pub fn glwe_ciphertext_plaintext_list_sub_assign<Scalar, InCont, PlainCont>(
/// let mut seeder = new_seeder();
/// let seeder = seeder.as_mut();
/// let mut encryption_generator =
/// EncryptionRandomGenerator::<ActivatedRandomGenerator>::new(seeder.seed(), seeder);
/// let mut secret_generator =
/// SecretRandomGenerator::<ActivatedRandomGenerator>::new(seeder.seed());
/// EncryptionRandomGenerator::<DefaultRandomGenerator>::new(seeder.seed(), seeder);
/// let mut secret_generator = SecretRandomGenerator::<DefaultRandomGenerator>::new(seeder.seed());
///
/// // Create the GlweSecretKey
/// let glwe_secret_key = allocate_and_generate_new_binary_glwe_secret_key(
@@ -499,9 +494,8 @@ pub fn glwe_ciphertext_plaintext_add_assign<Scalar, InCont>(
/// let mut seeder = new_seeder();
/// let seeder = seeder.as_mut();
/// let mut encryption_generator =
/// EncryptionRandomGenerator::<ActivatedRandomGenerator>::new(seeder.seed(), seeder);
/// let mut secret_generator =
/// SecretRandomGenerator::<ActivatedRandomGenerator>::new(seeder.seed());
/// EncryptionRandomGenerator::<DefaultRandomGenerator>::new(seeder.seed(), seeder);
/// let mut secret_generator = SecretRandomGenerator::<DefaultRandomGenerator>::new(seeder.seed());
///
/// // Create the GlweSecretKey
/// let glwe_secret_key = allocate_and_generate_new_binary_glwe_secret_key(
@@ -590,9 +584,8 @@ pub fn glwe_ciphertext_plaintext_sub_assign<Scalar, InCont>(
/// let mut seeder = new_seeder();
/// let seeder = seeder.as_mut();
/// let mut encryption_generator =
/// EncryptionRandomGenerator::<ActivatedRandomGenerator>::new(seeder.seed(), seeder);
/// let mut secret_generator =
/// SecretRandomGenerator::<ActivatedRandomGenerator>::new(seeder.seed());
/// EncryptionRandomGenerator::<DefaultRandomGenerator>::new(seeder.seed(), seeder);
/// let mut secret_generator = SecretRandomGenerator::<DefaultRandomGenerator>::new(seeder.seed());
///
/// // Create the GlweSecretKey
/// let glwe_secret_key = allocate_and_generate_new_binary_glwe_secret_key(
@@ -671,9 +664,8 @@ where
/// let mut seeder = new_seeder();
/// let seeder = seeder.as_mut();
/// let mut encryption_generator =
/// EncryptionRandomGenerator::<ActivatedRandomGenerator>::new(seeder.seed(), seeder);
/// let mut secret_generator =
/// SecretRandomGenerator::<ActivatedRandomGenerator>::new(seeder.seed());
/// EncryptionRandomGenerator::<DefaultRandomGenerator>::new(seeder.seed(), seeder);
/// let mut secret_generator = SecretRandomGenerator::<DefaultRandomGenerator>::new(seeder.seed());
///
/// // Create the GlweSecretKey
/// let glwe_secret_key = allocate_and_generate_new_binary_glwe_secret_key(
@@ -755,9 +747,8 @@ pub fn glwe_ciphertext_cleartext_mul_assign<Scalar, InCont>(
/// let mut seeder = new_seeder();
/// let seeder = seeder.as_mut();
/// let mut encryption_generator =
/// EncryptionRandomGenerator::<ActivatedRandomGenerator>::new(seeder.seed(), seeder);
/// let mut secret_generator =
/// SecretRandomGenerator::<ActivatedRandomGenerator>::new(seeder.seed());
/// EncryptionRandomGenerator::<DefaultRandomGenerator>::new(seeder.seed(), seeder);
/// let mut secret_generator = SecretRandomGenerator::<DefaultRandomGenerator>::new(seeder.seed());
///
/// // Create the GlweSecretKey
/// let glwe_secret_key = allocate_and_generate_new_binary_glwe_secret_key(
@@ -851,9 +842,8 @@ pub fn glwe_ciphertext_cleartext_mul<Scalar, InputCont, OutputCont>(
/// let mut seeder = new_seeder();
/// let seeder = seeder.as_mut();
/// let mut encryption_generator =
/// EncryptionRandomGenerator::<ActivatedRandomGenerator>::new(seeder.seed(), seeder);
/// let mut secret_generator =
/// SecretRandomGenerator::<ActivatedRandomGenerator>::new(seeder.seed());
/// EncryptionRandomGenerator::<DefaultRandomGenerator>::new(seeder.seed(), seeder);
/// let mut secret_generator = SecretRandomGenerator::<DefaultRandomGenerator>::new(seeder.seed());
///
/// // Create the GlweSecretKey
/// let glwe_secret_key = allocate_and_generate_new_binary_glwe_secret_key(
@@ -944,9 +934,8 @@ pub fn glwe_ciphertext_sub_assign<Scalar, LhsCont, RhsCont>(
/// let mut seeder = new_seeder();
/// let seeder = seeder.as_mut();
/// let mut encryption_generator =
/// EncryptionRandomGenerator::<ActivatedRandomGenerator>::new(seeder.seed(), seeder);
/// let mut secret_generator =
/// SecretRandomGenerator::<ActivatedRandomGenerator>::new(seeder.seed());
/// EncryptionRandomGenerator::<DefaultRandomGenerator>::new(seeder.seed(), seeder);
/// let mut secret_generator = SecretRandomGenerator::<DefaultRandomGenerator>::new(seeder.seed());
///
/// // Create the GlweSecretKey
/// let glwe_secret_key = allocate_and_generate_new_binary_glwe_secret_key(

15
tfhe/src/core_crypto/algorithms/glwe_sample_extraction.rs
View File

@@ -33,9 +33,8 @@ use rayon::prelude::*;
/// let mut seeder = new_seeder();
/// let seeder = seeder.as_mut();
/// let mut encryption_generator =
/// EncryptionRandomGenerator::<ActivatedRandomGenerator>::new(seeder.seed(), seeder);
/// let mut secret_generator =
/// SecretRandomGenerator::<ActivatedRandomGenerator>::new(seeder.seed());
/// EncryptionRandomGenerator::<DefaultRandomGenerator>::new(seeder.seed(), seeder);
/// let mut secret_generator = SecretRandomGenerator::<DefaultRandomGenerator>::new(seeder.seed());
///
/// // Create the GlweSecretKey
/// let glwe_secret_key = allocate_and_generate_new_binary_glwe_secret_key(
@@ -192,9 +191,8 @@ pub fn extract_lwe_sample_from_glwe_ciphertext<Scalar, InputCont, OutputCont>(
/// let mut seeder = new_seeder();
/// let seeder = seeder.as_mut();
/// let mut encryption_generator =
/// EncryptionRandomGenerator::<ActivatedRandomGenerator>::new(seeder.seed(), seeder);
/// let mut secret_generator =
/// SecretRandomGenerator::<ActivatedRandomGenerator>::new(seeder.seed());
/// EncryptionRandomGenerator::<DefaultRandomGenerator>::new(seeder.seed(), seeder);
/// let mut secret_generator = SecretRandomGenerator::<DefaultRandomGenerator>::new(seeder.seed());
///
/// // Create the GlweSecretKey
/// let glwe_secret_key = allocate_and_generate_new_binary_glwe_secret_key(
@@ -299,9 +297,8 @@ pub fn par_extract_lwe_sample_from_glwe_ciphertext<Scalar, InputCont, OutputCont
/// let mut seeder = new_seeder();
/// let seeder = seeder.as_mut();
/// let mut encryption_generator =
/// EncryptionRandomGenerator::<ActivatedRandomGenerator>::new(seeder.seed(), seeder);
/// let mut secret_generator =
/// SecretRandomGenerator::<ActivatedRandomGenerator>::new(seeder.seed());
/// EncryptionRandomGenerator::<DefaultRandomGenerator>::new(seeder.seed(), seeder);
/// let mut secret_generator = SecretRandomGenerator::<DefaultRandomGenerator>::new(seeder.seed());
///
/// // Create the GlweSecretKey
/// let glwe_secret_key = allocate_and_generate_new_binary_glwe_secret_key(

3
tfhe/src/core_crypto/algorithms/glwe_secret_key_generation.rs
View File

@@ -45,8 +45,7 @@ where
/// // Create the PRNG
/// let mut seeder = new_seeder();
/// let seeder = seeder.as_mut();
/// let mut secret_generator =
/// SecretRandomGenerator::<ActivatedRandomGenerator>::new(seeder.seed());
/// let mut secret_generator = SecretRandomGenerator::<DefaultRandomGenerator>::new(seeder.seed());
///
/// let mut glwe_secret_key =
/// GlweSecretKey::new_empty_key(0u64, glwe_size.to_glwe_dimension(), polynomial_size);

16
tfhe/src/core_crypto/algorithms/lwe_bootstrap_key_generation.rs
View File

@@ -4,7 +4,7 @@
use crate::core_crypto::algorithms::*;
use crate::core_crypto::commons::generators::EncryptionRandomGenerator;
use crate::core_crypto::commons::math::random::{ActivatedRandomGenerator, Distribution, Uniform};
use crate::core_crypto::commons::math::random::{DefaultRandomGenerator, Distribution, Uniform};
use crate::core_crypto::commons::parameters::*;
use crate::core_crypto::commons::traits::*;
use crate::core_crypto::entities::*;
@@ -35,9 +35,8 @@ use rayon::prelude::*;
/// let mut seeder = new_seeder();
/// let seeder = seeder.as_mut();
/// let mut encryption_generator =
/// EncryptionRandomGenerator::<ActivatedRandomGenerator>::new(seeder.seed(), seeder);
/// let mut secret_generator =
/// SecretRandomGenerator::<ActivatedRandomGenerator>::new(seeder.seed());
/// EncryptionRandomGenerator::<DefaultRandomGenerator>::new(seeder.seed(), seeder);
/// let mut secret_generator = SecretRandomGenerator::<DefaultRandomGenerator>::new(seeder.seed());
///
/// // Create the LweSecretKey
/// let input_lwe_secret_key =
@@ -208,9 +207,8 @@ where
/// let mut seeder = new_seeder();
/// let seeder = seeder.as_mut();
/// let mut encryption_generator =
/// EncryptionRandomGenerator::<ActivatedRandomGenerator>::new(seeder.seed(), seeder);
/// let mut secret_generator =
/// SecretRandomGenerator::<ActivatedRandomGenerator>::new(seeder.seed());
/// EncryptionRandomGenerator::<DefaultRandomGenerator>::new(seeder.seed(), seeder);
/// let mut secret_generator = SecretRandomGenerator::<DefaultRandomGenerator>::new(seeder.seed());
///
/// // Create the LweSecretKey
/// let input_lwe_secret_key =
@@ -403,7 +401,7 @@ pub fn generate_seeded_lwe_bootstrap_key<
output.polynomial_size()
);
let mut generator = EncryptionRandomGenerator::<ActivatedRandomGenerator>::new(
let mut generator = EncryptionRandomGenerator::<DefaultRandomGenerator>::new(
output.compression_seed().seed,
noise_seeder,
);
@@ -526,7 +524,7 @@ pub fn par_generate_seeded_lwe_bootstrap_key<
output.polynomial_size()
);
let mut generator = EncryptionRandomGenerator::<ActivatedRandomGenerator>::new(
let mut generator = EncryptionRandomGenerator::<DefaultRandomGenerator>::new(
output.compression_seed().seed,
noise_seeder,
);

4
tfhe/src/core_crypto/algorithms/lwe_compact_public_key_generation.rs
View File

@@ -7,7 +7,7 @@ use crate::core_crypto::commons::generators::EncryptionRandomGenerator;
use crate::core_crypto::commons::math::random::{Distribution, Uniform};
use crate::core_crypto::commons::traits::*;
use crate::core_crypto::entities::*;
use crate::core_crypto::prelude::ActivatedRandomGenerator;
use crate::core_crypto::prelude::DefaultRandomGenerator;
use slice_algorithms::*;
/// Fill an [`LWE compact public key`](`LweCompactPublicKey`) with an actual public key constructed
@@ -124,7 +124,7 @@ pub fn generate_seeded_lwe_compact_public_key<
output.lwe_dimension()
);
let mut generator = EncryptionRandomGenerator::<ActivatedRandomGenerator>::new(
let mut generator = EncryptionRandomGenerator::<DefaultRandomGenerator>::new(
output.compression_seed().seed,
noise_seeder,
);

108
tfhe/src/core_crypto/algorithms/lwe_encryption.rs
View File

@@ -8,8 +8,7 @@ use crate::core_crypto::commons::generators::{EncryptionRandomGenerator, SecretR
#[cfg(feature = "zk-pok")]
use crate::core_crypto::commons::math::random::BoundedDistribution;
use crate::core_crypto::commons::math::random::{
ActivatedRandomGenerator, Distribution, RandomGenerable, RandomGenerator, Uniform,
UniformBinary,
DefaultRandomGenerator, Distribution, RandomGenerable, RandomGenerator, Uniform, UniformBinary,
};
use crate::core_crypto::commons::parameters::*;
use crate::core_crypto::commons::traits::*;
@@ -200,9 +199,8 @@ pub fn fill_lwe_mask_and_body_for_encryption_other_mod<
/// let mut seeder = new_seeder();
/// let seeder = seeder.as_mut();
/// let mut encryption_generator =
/// EncryptionRandomGenerator::<ActivatedRandomGenerator>::new(seeder.seed(), seeder);
/// let mut secret_generator =
/// SecretRandomGenerator::<ActivatedRandomGenerator>::new(seeder.seed());
/// EncryptionRandomGenerator::<DefaultRandomGenerator>::new(seeder.seed(), seeder);
/// let mut secret_generator = SecretRandomGenerator::<DefaultRandomGenerator>::new(seeder.seed());
///
/// // Create the LweSecretKey
/// let lwe_secret_key =
@@ -292,9 +290,8 @@ pub fn encrypt_lwe_ciphertext<Scalar, NoiseDistribution, KeyCont, OutputCont, Ge
/// let mut seeder = new_seeder();
/// let seeder = seeder.as_mut();
/// let mut encryption_generator =
/// EncryptionRandomGenerator::<ActivatedRandomGenerator>::new(seeder.seed(), seeder);
/// let mut secret_generator =
/// SecretRandomGenerator::<ActivatedRandomGenerator>::new(seeder.seed());
/// EncryptionRandomGenerator::<DefaultRandomGenerator>::new(seeder.seed(), seeder);
/// let mut secret_generator = SecretRandomGenerator::<DefaultRandomGenerator>::new(seeder.seed());
///
/// // Create the LweSecretKey
/// let lwe_secret_key =
@@ -380,8 +377,7 @@ where
/// // Create the PRNG
/// let mut seeder = new_seeder();
/// let seeder = seeder.as_mut();
/// let mut secret_generator =
/// SecretRandomGenerator::<ActivatedRandomGenerator>::new(seeder.seed());
/// let mut secret_generator = SecretRandomGenerator::<DefaultRandomGenerator>::new(seeder.seed());
///
/// // Create the plaintext
/// let msg = 3u64;
@@ -454,8 +450,7 @@ pub fn trivially_encrypt_lwe_ciphertext<Scalar, OutputCont>(
/// // Create the PRNG
/// let mut seeder = new_seeder();
/// let seeder = seeder.as_mut();
/// let mut secret_generator =
/// SecretRandomGenerator::<ActivatedRandomGenerator>::new(seeder.seed());
/// let mut secret_generator = SecretRandomGenerator::<DefaultRandomGenerator>::new(seeder.seed());
///
/// // Create the plaintext
/// let msg = 3u64;
@@ -634,9 +629,8 @@ where
/// let mut seeder = new_seeder();
/// let seeder = seeder.as_mut();
/// let mut encryption_generator =
/// EncryptionRandomGenerator::<ActivatedRandomGenerator>::new(seeder.seed(), seeder);
/// let mut secret_generator =
/// SecretRandomGenerator::<ActivatedRandomGenerator>::new(seeder.seed());
/// EncryptionRandomGenerator::<DefaultRandomGenerator>::new(seeder.seed(), seeder);
/// let mut secret_generator = SecretRandomGenerator::<DefaultRandomGenerator>::new(seeder.seed());
///
/// // Create the LweSecretKey
/// let lwe_secret_key =
@@ -745,9 +739,8 @@ pub fn encrypt_lwe_ciphertext_list<Scalar, NoiseDistribution, KeyCont, OutputCon
/// let mut seeder = new_seeder();
/// let seeder = seeder.as_mut();
/// let mut encryption_generator =
/// EncryptionRandomGenerator::<ActivatedRandomGenerator>::new(seeder.seed(), seeder);
/// let mut secret_generator =
/// SecretRandomGenerator::<ActivatedRandomGenerator>::new(seeder.seed());
/// EncryptionRandomGenerator::<DefaultRandomGenerator>::new(seeder.seed(), seeder);
/// let mut secret_generator = SecretRandomGenerator::<DefaultRandomGenerator>::new(seeder.seed());
///
/// // Create the LweSecretKey
/// let lwe_secret_key =
@@ -899,9 +892,8 @@ pub fn decrypt_lwe_ciphertext_list<Scalar, KeyCont, InputCont, OutputCont>(
/// let mut seeder = new_seeder();
/// let seeder = seeder.as_mut();
/// let mut encryption_generator =
/// EncryptionRandomGenerator::<ActivatedRandomGenerator>::new(seeder.seed(), seeder);
/// let mut secret_generator =
/// SecretRandomGenerator::<ActivatedRandomGenerator>::new(seeder.seed());
/// EncryptionRandomGenerator::<DefaultRandomGenerator>::new(seeder.seed(), seeder);
/// let mut secret_generator = SecretRandomGenerator::<DefaultRandomGenerator>::new(seeder.seed());
///
/// // Create the LweSecretKey
/// let lwe_secret_key =
@@ -1016,8 +1008,7 @@ pub fn encrypt_lwe_ciphertext_with_public_key<Scalar, KeyCont, OutputCont, Gen>(
/// // Create the PRNG
/// let mut seeder = new_seeder();
/// let seeder = seeder.as_mut();
/// let mut secret_generator =
/// SecretRandomGenerator::<ActivatedRandomGenerator>::new(seeder.seed());
/// let mut secret_generator = SecretRandomGenerator::<DefaultRandomGenerator>::new(seeder.seed());
///
/// // Create the LweSecretKey
/// let lwe_secret_key =
@@ -1115,8 +1106,7 @@ pub fn encrypt_lwe_ciphertext_with_seeded_public_key<Scalar, KeyCont, OutputCont
/// // Create the PRNG
/// let mut seeder = new_seeder();
/// let seeder = seeder.as_mut();
/// let mut secret_generator =
/// SecretRandomGenerator::<ActivatedRandomGenerator>::new(seeder.seed());
/// let mut secret_generator = SecretRandomGenerator::<DefaultRandomGenerator>::new(seeder.seed());
///
/// // Create the LweSecretKey
/// let lwe_secret_key =
@@ -1232,7 +1222,7 @@ pub fn encrypt_lwe_ciphertext_iterator_with_seeded_public_key<Scalar, KeyCont, O
);
let mut random_generator =
RandomGenerator::<ActivatedRandomGenerator>::new(lwe_public_key.compression_seed().seed);
RandomGenerator::<DefaultRandomGenerator>::new(lwe_public_key.compression_seed().seed);
// Add the public encryption of zeros to get the zero encryption
for public_encryption_of_zero_body in lwe_public_key.iter() {
@@ -1343,8 +1333,7 @@ pub fn encrypt_seeded_lwe_ciphertext_list_with_existing_generator<
/// // Create the PRNG
/// let mut seeder = new_seeder();
/// let seeder = seeder.as_mut();
/// let mut secret_generator =
/// SecretRandomGenerator::<ActivatedRandomGenerator>::new(seeder.seed());
/// let mut secret_generator = SecretRandomGenerator::<DefaultRandomGenerator>::new(seeder.seed());
///
/// // Create the LweSecretKey
/// let lwe_secret_key =
@@ -1418,7 +1407,7 @@ pub fn encrypt_seeded_lwe_ciphertext_list<
// Maybe Sized allows to pass Box<dyn Seeder>.
NoiseSeeder: Seeder + ?Sized,
{
let mut generator = EncryptionRandomGenerator::<ActivatedRandomGenerator>::new(
let mut generator = EncryptionRandomGenerator::<DefaultRandomGenerator>::new(
output.compression_seed().seed,
noise_seeder,
);
@@ -1512,8 +1501,7 @@ pub fn par_encrypt_seeded_lwe_ciphertext_list_with_existing_generator<
/// // Create the PRNG
/// let mut seeder = new_seeder();
/// let seeder = seeder.as_mut();
/// let mut secret_generator =
/// SecretRandomGenerator::<ActivatedRandomGenerator>::new(seeder.seed());
/// let mut secret_generator = SecretRandomGenerator::<DefaultRandomGenerator>::new(seeder.seed());
///
/// // Create the LweSecretKey
/// let lwe_secret_key =
@@ -1587,7 +1575,7 @@ pub fn par_encrypt_seeded_lwe_ciphertext_list<
// Maybe Sized allows to pass Box<dyn Seeder>.
NoiseSeeder: Seeder + ?Sized,
{
let mut generator = EncryptionRandomGenerator::<ActivatedRandomGenerator>::new(
let mut generator = EncryptionRandomGenerator::<DefaultRandomGenerator>::new(
output.compression_seed().seed,
noise_seeder,
);
@@ -1656,8 +1644,7 @@ pub fn encrypt_seeded_lwe_ciphertext_with_existing_generator<
/// // Create the PRNG
/// let mut seeder = new_seeder();
/// let seeder = seeder.as_mut();
/// let mut secret_generator =
/// SecretRandomGenerator::<ActivatedRandomGenerator>::new(seeder.seed());
/// let mut secret_generator = SecretRandomGenerator::<DefaultRandomGenerator>::new(seeder.seed());
///
/// // Create the LweSecretKey
/// let lwe_secret_key =
@@ -1712,7 +1699,7 @@ pub fn encrypt_seeded_lwe_ciphertext<Scalar, NoiseDistribution, KeyCont, NoiseSe
// Maybe Sized allows to pass Box<dyn Seeder>.
NoiseSeeder: Seeder + ?Sized,
{
let mut encryption_generator = EncryptionRandomGenerator::<ActivatedRandomGenerator>::new(
let mut encryption_generator = EncryptionRandomGenerator::<DefaultRandomGenerator>::new(
output.compression_seed().seed,
noise_seeder,
);
@@ -1748,8 +1735,7 @@ pub fn encrypt_seeded_lwe_ciphertext<Scalar, NoiseDistribution, KeyCont, NoiseSe
/// // Create the PRNG
/// let mut seeder = new_seeder();
/// let seeder = seeder.as_mut();
/// let mut secret_generator =
/// SecretRandomGenerator::<ActivatedRandomGenerator>::new(seeder.seed());
/// let mut secret_generator = SecretRandomGenerator::<DefaultRandomGenerator>::new(seeder.seed());
///
/// // Create the LweSecretKey
/// let lwe_secret_key =
@@ -2031,9 +2017,8 @@ where
/// let mut seeder = new_seeder();
/// let seeder = seeder.as_mut();
/// let mut encryption_generator =
/// EncryptionRandomGenerator::<ActivatedRandomGenerator>::new(seeder.seed(), seeder);
/// let mut secret_generator =
/// SecretRandomGenerator::<ActivatedRandomGenerator>::new(seeder.seed());
/// EncryptionRandomGenerator::<DefaultRandomGenerator>::new(seeder.seed(), seeder);
/// let mut secret_generator = SecretRandomGenerator::<DefaultRandomGenerator>::new(seeder.seed());
///
/// // Create the LweSecretKey
/// let lwe_secret_key =
@@ -2148,10 +2133,9 @@ pub fn encrypt_lwe_ciphertext_with_compact_public_key<
/// let mut seeder = new_seeder();
/// let seeder = seeder.as_mut();
/// let mut encryption_generator =
/// EncryptionRandomGenerator::<ActivatedRandomGenerator>::new(seeder.seed(), seeder);
/// let mut secret_generator =
/// SecretRandomGenerator::<ActivatedRandomGenerator>::new(seeder.seed());
/// let mut random_generator = RandomGenerator::<ActivatedRandomGenerator>::new(seeder.seed());
/// EncryptionRandomGenerator::<DefaultRandomGenerator>::new(seeder.seed(), seeder);
/// let mut secret_generator = SecretRandomGenerator::<DefaultRandomGenerator>::new(seeder.seed());
/// let mut random_generator = RandomGenerator::<DefaultRandomGenerator>::new(seeder.seed());
///
/// // Create the LweSecretKey
/// let lwe_secret_key =
@@ -2460,9 +2444,8 @@ where
/// let mut seeder = new_seeder();
/// let seeder = seeder.as_mut();
/// let mut encryption_generator =
/// EncryptionRandomGenerator::<ActivatedRandomGenerator>::new(seeder.seed(), seeder);
/// let mut secret_generator =
/// SecretRandomGenerator::<ActivatedRandomGenerator>::new(seeder.seed());
/// EncryptionRandomGenerator::<DefaultRandomGenerator>::new(seeder.seed(), seeder);
/// let mut secret_generator = SecretRandomGenerator::<DefaultRandomGenerator>::new(seeder.seed());
///
/// // Create the LweSecretKey
/// let lwe_secret_key =
@@ -2603,10 +2586,9 @@ pub fn encrypt_lwe_compact_ciphertext_list_with_compact_public_key<
/// let mut seeder = new_seeder();
/// let seeder = seeder.as_mut();
/// let mut encryption_generator =
/// EncryptionRandomGenerator::<ActivatedRandomGenerator>::new(seeder.seed(), seeder);
/// let mut secret_generator =
/// SecretRandomGenerator::<ActivatedRandomGenerator>::new(seeder.seed());
/// let mut random_generator = RandomGenerator::<ActivatedRandomGenerator>::new(seeder.seed());
/// EncryptionRandomGenerator::<DefaultRandomGenerator>::new(seeder.seed(), seeder);
/// let mut secret_generator = SecretRandomGenerator::<DefaultRandomGenerator>::new(seeder.seed());
/// let mut random_generator = RandomGenerator::<DefaultRandomGenerator>::new(seeder.seed());
///
/// let crs = CompactPkeCrs::new(
/// lwe_dimension,
@@ -2942,9 +2924,8 @@ where
/// let mut seeder = new_seeder();
/// let seeder = seeder.as_mut();
/// let mut encryption_generator =
/// EncryptionRandomGenerator::<ActivatedRandomGenerator>::new(seeder.seed(), seeder);
/// let mut secret_generator =
/// SecretRandomGenerator::<ActivatedRandomGenerator>::new(seeder.seed());
/// EncryptionRandomGenerator::<DefaultRandomGenerator>::new(seeder.seed(), seeder);
/// let mut secret_generator = SecretRandomGenerator::<DefaultRandomGenerator>::new(seeder.seed());
///
/// // Create the LweSecretKey
/// let lwe_secret_key =
@@ -3089,10 +3070,9 @@ pub fn par_encrypt_lwe_compact_ciphertext_list_with_compact_public_key<
/// let mut seeder = new_seeder();
/// let seeder = seeder.as_mut();
/// let mut encryption_generator =
/// EncryptionRandomGenerator::<ActivatedRandomGenerator>::new(seeder.seed(), seeder);
/// let mut secret_generator =
/// SecretRandomGenerator::<ActivatedRandomGenerator>::new(seeder.seed());
/// let mut random_generator = RandomGenerator::<ActivatedRandomGenerator>::new(seeder.seed());
/// EncryptionRandomGenerator::<DefaultRandomGenerator>::new(seeder.seed(), seeder);
/// let mut secret_generator = SecretRandomGenerator::<DefaultRandomGenerator>::new(seeder.seed());
/// let mut random_generator = RandomGenerator::<DefaultRandomGenerator>::new(seeder.seed());
///
/// let crs = CompactPkeCrs::new(
/// lwe_dimension,
@@ -3363,13 +3343,13 @@ mod test {
let par_lwe_ct_list = {
let mut deterministic_seeder =
DeterministicSeeder::<ActivatedRandomGenerator>::new(seed);
DeterministicSeeder::<DefaultRandomGenerator>::new(seed);
let mut secret_random_generator =
SecretRandomGenerator::<ActivatedRandomGenerator>::new(
SecretRandomGenerator::<DefaultRandomGenerator>::new(
deterministic_seeder.seed(),
);
let mut encryption_random_generator =
EncryptionRandomGenerator::<ActivatedRandomGenerator>::new(
EncryptionRandomGenerator::<DefaultRandomGenerator>::new(
deterministic_seeder.seed(),
&mut deterministic_seeder,
);
@@ -3430,13 +3410,13 @@ mod test {
let ser_lwe_ct_list = {
let mut deterministic_seeder =
DeterministicSeeder::<ActivatedRandomGenerator>::new(seed);
DeterministicSeeder::<DefaultRandomGenerator>::new(seed);
let mut secret_random_generator =
SecretRandomGenerator::<ActivatedRandomGenerator>::new(
SecretRandomGenerator::<DefaultRandomGenerator>::new(
deterministic_seeder.seed(),
);
let mut encryption_random_generator =
EncryptionRandomGenerator::<ActivatedRandomGenerator>::new(
EncryptionRandomGenerator::<DefaultRandomGenerator>::new(
deterministic_seeder.seed(),
&mut deterministic_seeder,
);

15
tfhe/src/core_crypto/algorithms/lwe_keyswitch.rs
View File

@@ -44,9 +44,8 @@ use rayon::prelude::*;
/// let mut seeder = new_seeder();
/// let seeder = seeder.as_mut();
/// let mut encryption_generator =
/// EncryptionRandomGenerator::<ActivatedRandomGenerator>::new(seeder.seed(), seeder);
/// let mut secret_generator =
/// SecretRandomGenerator::<ActivatedRandomGenerator>::new(seeder.seed());
/// EncryptionRandomGenerator::<DefaultRandomGenerator>::new(seeder.seed(), seeder);
/// let mut secret_generator = SecretRandomGenerator::<DefaultRandomGenerator>::new(seeder.seed());
///
/// // Create the LweSecretKey
/// let input_lwe_secret_key =
@@ -476,9 +475,8 @@ pub fn keyswitch_lwe_ciphertext_with_scalar_change<
/// let mut seeder = new_seeder();
/// let seeder = seeder.as_mut();
/// let mut encryption_generator =
/// EncryptionRandomGenerator::<ActivatedRandomGenerator>::new(seeder.seed(), seeder);
/// let mut secret_generator =
/// SecretRandomGenerator::<ActivatedRandomGenerator>::new(seeder.seed());
/// EncryptionRandomGenerator::<DefaultRandomGenerator>::new(seeder.seed(), seeder);
/// let mut secret_generator = SecretRandomGenerator::<DefaultRandomGenerator>::new(seeder.seed());
///
/// // Create the LweSecretKey
/// let input_lwe_secret_key =
@@ -584,9 +582,8 @@ pub fn par_keyswitch_lwe_ciphertext<Scalar, KSKCont, InputCont, OutputCont>(
/// let mut seeder = new_seeder();
/// let seeder = seeder.as_mut();
/// let mut encryption_generator =
/// EncryptionRandomGenerator::<ActivatedRandomGenerator>::new(seeder.seed(), seeder);
/// let mut secret_generator =
/// SecretRandomGenerator::<ActivatedRandomGenerator>::new(seeder.seed());
/// EncryptionRandomGenerator::<DefaultRandomGenerator>::new(seeder.seed(), seeder);
/// let mut secret_generator = SecretRandomGenerator::<DefaultRandomGenerator>::new(seeder.seed());
///
/// // Create the LweSecretKey
/// let input_lwe_secret_key =

12
tfhe/src/core_crypto/algorithms/lwe_keyswitch_key_generation.rs
View File

@@ -7,7 +7,7 @@ use crate::core_crypto::commons::generators::EncryptionRandomGenerator;
use crate::core_crypto::commons::math::decomposition::{
DecompositionLevel, DecompositionTerm, DecompositionTermNonNative,
};
use crate::core_crypto::commons::math::random::{ActivatedRandomGenerator, Distribution, Uniform};
use crate::core_crypto::commons::math::random::{DefaultRandomGenerator, Distribution, Uniform};
use crate::core_crypto::commons::parameters::*;
use crate::core_crypto::commons::traits::*;
use crate::core_crypto::entities::*;
@@ -33,9 +33,8 @@ use crate::core_crypto::entities::*;
/// let mut seeder = new_seeder();
/// let seeder = seeder.as_mut();
/// let mut encryption_generator =
/// EncryptionRandomGenerator::<ActivatedRandomGenerator>::new(seeder.seed(), seeder);
/// let mut secret_generator =
/// SecretRandomGenerator::<ActivatedRandomGenerator>::new(seeder.seed());
/// EncryptionRandomGenerator::<DefaultRandomGenerator>::new(seeder.seed(), seeder);
/// let mut secret_generator = SecretRandomGenerator::<DefaultRandomGenerator>::new(seeder.seed());
///
/// // Create the LweSecretKey
/// let input_lwe_secret_key =
@@ -326,8 +325,7 @@ where
/// // Create the PRNG
/// let mut seeder = new_seeder();
/// let seeder = seeder.as_mut();
/// let mut secret_generator =
/// SecretRandomGenerator::<ActivatedRandomGenerator>::new(seeder.seed());
/// let mut secret_generator = SecretRandomGenerator::<DefaultRandomGenerator>::new(seeder.seed());
///
/// // Create the LweSecretKey
/// let input_lwe_secret_key =
@@ -403,7 +401,7 @@ pub fn generate_seeded_lwe_keyswitch_key<
let mut decomposition_plaintexts_buffer =
PlaintextListOwned::new(Scalar::ZERO, PlaintextCount(decomp_level_count.0));
let mut generator = EncryptionRandomGenerator::<ActivatedRandomGenerator>::new(
let mut generator = EncryptionRandomGenerator::<DefaultRandomGenerator>::new(
lwe_keyswitch_key.compression_seed().seed,
noise_seeder,
);

45
tfhe/src/core_crypto/algorithms/lwe_linear_algebra.rs
View File

@@ -26,9 +26,8 @@ use crate::core_crypto::entities::*;
/// let mut seeder = new_seeder();
/// let seeder = seeder.as_mut();
/// let mut encryption_generator =
/// EncryptionRandomGenerator::<ActivatedRandomGenerator>::new(seeder.seed(), seeder);
/// let mut secret_generator =
/// SecretRandomGenerator::<ActivatedRandomGenerator>::new(seeder.seed());
/// EncryptionRandomGenerator::<DefaultRandomGenerator>::new(seeder.seed(), seeder);
/// let mut secret_generator = SecretRandomGenerator::<DefaultRandomGenerator>::new(seeder.seed());
///
/// // Create the LweSecretKey
/// let lwe_secret_key =
@@ -148,9 +147,8 @@ pub fn lwe_ciphertext_add_assign_other_mod<Scalar, LhsCont, RhsCont>(
/// let mut seeder = new_seeder();
/// let seeder = seeder.as_mut();
/// let mut encryption_generator =
/// EncryptionRandomGenerator::<ActivatedRandomGenerator>::new(seeder.seed(), seeder);
/// let mut secret_generator =
/// SecretRandomGenerator::<ActivatedRandomGenerator>::new(seeder.seed());
/// EncryptionRandomGenerator::<DefaultRandomGenerator>::new(seeder.seed(), seeder);
/// let mut secret_generator = SecretRandomGenerator::<DefaultRandomGenerator>::new(seeder.seed());
///
/// // Create the LweSecretKey
/// let lwe_secret_key =
@@ -238,9 +236,8 @@ pub fn lwe_ciphertext_add<Scalar, OutputCont, LhsCont, RhsCont>(
/// let mut seeder = new_seeder();
/// let seeder = seeder.as_mut();
/// let mut encryption_generator =
/// EncryptionRandomGenerator::<ActivatedRandomGenerator>::new(seeder.seed(), seeder);
/// let mut secret_generator =
/// SecretRandomGenerator::<ActivatedRandomGenerator>::new(seeder.seed());
/// EncryptionRandomGenerator::<DefaultRandomGenerator>::new(seeder.seed(), seeder);
/// let mut secret_generator = SecretRandomGenerator::<DefaultRandomGenerator>::new(seeder.seed());
///
/// // Create the LweSecretKey
/// let lwe_secret_key =
@@ -347,9 +344,8 @@ pub fn lwe_ciphertext_plaintext_add_assign_other_mod<Scalar, InCont>(
/// let mut seeder = new_seeder();
/// let seeder = seeder.as_mut();
/// let mut encryption_generator =
/// EncryptionRandomGenerator::<ActivatedRandomGenerator>::new(seeder.seed(), seeder);
/// let mut secret_generator =
/// SecretRandomGenerator::<ActivatedRandomGenerator>::new(seeder.seed());
/// EncryptionRandomGenerator::<DefaultRandomGenerator>::new(seeder.seed(), seeder);
/// let mut secret_generator = SecretRandomGenerator::<DefaultRandomGenerator>::new(seeder.seed());
///
/// // Create the LweSecretKey
/// let lwe_secret_key =
@@ -455,9 +451,8 @@ pub fn lwe_ciphertext_plaintext_sub_assign_other_mod<Scalar, InCont>(
/// let mut seeder = new_seeder();
/// let seeder = seeder.as_mut();
/// let mut encryption_generator =
/// EncryptionRandomGenerator::<ActivatedRandomGenerator>::new(seeder.seed(), seeder);
/// let mut secret_generator =
/// SecretRandomGenerator::<ActivatedRandomGenerator>::new(seeder.seed());
/// EncryptionRandomGenerator::<DefaultRandomGenerator>::new(seeder.seed(), seeder);
/// let mut secret_generator = SecretRandomGenerator::<DefaultRandomGenerator>::new(seeder.seed());
///
/// // Create the LweSecretKey
/// let lwe_secret_key =
@@ -520,9 +515,8 @@ where
/// let mut seeder = new_seeder();
/// let seeder = seeder.as_mut();
/// let mut encryption_generator =
/// EncryptionRandomGenerator::<ActivatedRandomGenerator>::new(seeder.seed(), seeder);
/// let mut secret_generator =
/// SecretRandomGenerator::<ActivatedRandomGenerator>::new(seeder.seed());
/// EncryptionRandomGenerator::<DefaultRandomGenerator>::new(seeder.seed(), seeder);
/// let mut secret_generator = SecretRandomGenerator::<DefaultRandomGenerator>::new(seeder.seed());
///
/// // Create the LweSecretKey
/// let lwe_secret_key =
@@ -588,9 +582,8 @@ pub fn lwe_ciphertext_cleartext_mul_assign<Scalar, InCont>(
/// let mut seeder = new_seeder();
/// let seeder = seeder.as_mut();
/// let mut encryption_generator =
/// EncryptionRandomGenerator::<ActivatedRandomGenerator>::new(seeder.seed(), seeder);
/// let mut secret_generator =
/// SecretRandomGenerator::<ActivatedRandomGenerator>::new(seeder.seed());
/// EncryptionRandomGenerator::<DefaultRandomGenerator>::new(seeder.seed(), seeder);
/// let mut secret_generator = SecretRandomGenerator::<DefaultRandomGenerator>::new(seeder.seed());
///
/// // Create the LweSecretKey
/// let lwe_secret_key =
@@ -668,9 +661,8 @@ pub fn lwe_ciphertext_cleartext_mul<Scalar, InputCont, OutputCont>(
/// let mut seeder = new_seeder();
/// let seeder = seeder.as_mut();
/// let mut encryption_generator =
/// EncryptionRandomGenerator::<ActivatedRandomGenerator>::new(seeder.seed(), seeder);
/// let mut secret_generator =
/// SecretRandomGenerator::<ActivatedRandomGenerator>::new(seeder.seed());
/// EncryptionRandomGenerator::<DefaultRandomGenerator>::new(seeder.seed(), seeder);
/// let mut secret_generator = SecretRandomGenerator::<DefaultRandomGenerator>::new(seeder.seed());
///
/// // Create the LweSecretKey
/// let lwe_secret_key =
@@ -747,9 +739,8 @@ pub fn lwe_ciphertext_sub_assign<Scalar, LhsCont, RhsCont>(
/// let mut seeder = new_seeder();
/// let seeder = seeder.as_mut();
/// let mut encryption_generator =
/// EncryptionRandomGenerator::<ActivatedRandomGenerator>::new(seeder.seed(), seeder);
/// let mut secret_generator =
/// SecretRandomGenerator::<ActivatedRandomGenerator>::new(seeder.seed());
/// EncryptionRandomGenerator::<DefaultRandomGenerator>::new(seeder.seed(), seeder);
/// let mut secret_generator = SecretRandomGenerator::<DefaultRandomGenerator>::new(seeder.seed());
///
/// // Create the LweSecretKey
/// let lwe_secret_key =

16
tfhe/src/core_crypto/algorithms/lwe_multi_bit_bootstrap_key_generation.rs
View File

@@ -3,7 +3,7 @@
use crate::core_crypto::algorithms::*;
use crate::core_crypto::commons::generators::EncryptionRandomGenerator;
use crate::core_crypto::commons::math::random::{ActivatedRandomGenerator, Distribution, Uniform};
use crate::core_crypto::commons::math::random::{DefaultRandomGenerator, Distribution, Uniform};
use crate::core_crypto::commons::parameters::*;
use crate::core_crypto::commons::traits::*;
use crate::core_crypto::entities::*;
@@ -29,9 +29,8 @@ use rayon::prelude::*;
/// let mut seeder = new_seeder();
/// let seeder = seeder.as_mut();
/// let mut encryption_generator =
/// EncryptionRandomGenerator::<ActivatedRandomGenerator>::new(seeder.seed(), seeder);
/// let mut secret_generator =
/// SecretRandomGenerator::<ActivatedRandomGenerator>::new(seeder.seed());
/// EncryptionRandomGenerator::<DefaultRandomGenerator>::new(seeder.seed(), seeder);
/// let mut secret_generator = SecretRandomGenerator::<DefaultRandomGenerator>::new(seeder.seed());
///
/// // Create the LweSecretKey
/// let input_lwe_secret_key =
@@ -233,9 +232,8 @@ where
/// let mut seeder = new_seeder();
/// let seeder = seeder.as_mut();
/// let mut encryption_generator =
/// EncryptionRandomGenerator::<ActivatedRandomGenerator>::new(seeder.seed(), seeder);
/// let mut secret_generator =
/// SecretRandomGenerator::<ActivatedRandomGenerator>::new(seeder.seed());
/// EncryptionRandomGenerator::<DefaultRandomGenerator>::new(seeder.seed(), seeder);
/// let mut secret_generator = SecretRandomGenerator::<DefaultRandomGenerator>::new(seeder.seed());
///
/// // Create the LweSecretKey
/// let input_lwe_secret_key =
@@ -517,7 +515,7 @@ pub fn generate_seeded_lwe_multi_bit_bootstrap_key<
output.polynomial_size()
);
let mut generator = EncryptionRandomGenerator::<ActivatedRandomGenerator>::new(
let mut generator = EncryptionRandomGenerator::<DefaultRandomGenerator>::new(
output.compression_seed().seed,
noise_seeder,
);
@@ -690,7 +688,7 @@ pub fn par_generate_seeded_lwe_multi_bit_bootstrap_key<
output.polynomial_size()
);
let mut generator = EncryptionRandomGenerator::<ActivatedRandomGenerator>::new(
let mut generator = EncryptionRandomGenerator::<DefaultRandomGenerator>::new(
output.compression_seed().seed,
noise_seeder,
);

10
tfhe/src/core_crypto/algorithms/lwe_multi_bit_programmable_bootstrapping.rs
View File

@@ -174,13 +174,12 @@ pub fn prepare_multi_bit_ggsw_mem_optimized<GgswBufferCont, GgswGroupCont, Fouri
/// let seeder = boxed_seeder.as_mut();
///
/// // Create a generator which uses a CSPRNG to generate secret keys
/// let mut secret_generator =
/// SecretRandomGenerator::<ActivatedRandomGenerator>::new(seeder.seed());
/// let mut secret_generator = SecretRandomGenerator::<DefaultRandomGenerator>::new(seeder.seed());
///
/// // Create a generator which uses two CSPRNGs to generate public masks and secret encryption
/// // noise
/// let mut encryption_generator =
/// EncryptionRandomGenerator::<ActivatedRandomGenerator>::new(seeder.seed(), seeder);
/// EncryptionRandomGenerator::<DefaultRandomGenerator>::new(seeder.seed(), seeder);
///
/// println!("Generating keys...");
///
@@ -852,13 +851,12 @@ pub fn multi_bit_deterministic_blind_rotate_assign<Scalar, OutputCont, KeyCont>(
/// let seeder = boxed_seeder.as_mut();
///
/// // Create a generator which uses a CSPRNG to generate secret keys
/// let mut secret_generator =
/// SecretRandomGenerator::<ActivatedRandomGenerator>::new(seeder.seed());
/// let mut secret_generator = SecretRandomGenerator::<DefaultRandomGenerator>::new(seeder.seed());
///
/// // Create a generator which uses two CSPRNGs to generate public masks and secret encryption
/// // noise
/// let mut encryption_generator =
/// EncryptionRandomGenerator::<ActivatedRandomGenerator>::new(seeder.seed(), seeder);
/// EncryptionRandomGenerator::<DefaultRandomGenerator>::new(seeder.seed(), seeder);
///
/// println!("Generating keys...");
///

20
tfhe/src/core_crypto/algorithms/lwe_packing_keyswitch.rs
View File

@@ -34,9 +34,8 @@ use rayon::prelude::*;
/// let mut seeder = new_seeder();
/// let seeder = seeder.as_mut();
/// let mut encryption_generator =
/// EncryptionRandomGenerator::<ActivatedRandomGenerator>::new(seeder.seed(), seeder);
/// let mut secret_generator =
/// SecretRandomGenerator::<ActivatedRandomGenerator>::new(seeder.seed());
/// EncryptionRandomGenerator::<DefaultRandomGenerator>::new(seeder.seed(), seeder);
/// let mut secret_generator = SecretRandomGenerator::<DefaultRandomGenerator>::new(seeder.seed());
///
/// // Create the LweSecretKey
/// let input_lwe_secret_key =
@@ -212,9 +211,8 @@ pub fn keyswitch_lwe_ciphertext_into_glwe_ciphertext<Scalar, KeyCont, InputCont,
/// let mut seeder = new_seeder();
/// let seeder = seeder.as_mut();
/// let mut encryption_generator =
/// EncryptionRandomGenerator::<ActivatedRandomGenerator>::new(seeder.seed(), seeder);
/// let mut secret_generator =
/// SecretRandomGenerator::<ActivatedRandomGenerator>::new(seeder.seed());
/// EncryptionRandomGenerator::<DefaultRandomGenerator>::new(seeder.seed(), seeder);
/// let mut secret_generator = SecretRandomGenerator::<DefaultRandomGenerator>::new(seeder.seed());
///
/// // Create the LweSecretKey
/// let input_lwe_secret_key =
@@ -405,9 +403,8 @@ pub fn keyswitch_lwe_ciphertext_list_and_pack_in_glwe_ciphertext<
/// let mut seeder = new_seeder();
/// let seeder = seeder.as_mut();
/// let mut encryption_generator =
/// EncryptionRandomGenerator::<ActivatedRandomGenerator>::new(seeder.seed(), seeder);
/// let mut secret_generator =
/// SecretRandomGenerator::<ActivatedRandomGenerator>::new(seeder.seed());
/// EncryptionRandomGenerator::<DefaultRandomGenerator>::new(seeder.seed(), seeder);
/// let mut secret_generator = SecretRandomGenerator::<DefaultRandomGenerator>::new(seeder.seed());
///
/// // Create the LweSecretKey
/// let input_lwe_secret_key =
@@ -540,9 +537,8 @@ pub fn par_keyswitch_lwe_ciphertext_list_and_pack_in_glwe_ciphertext<
/// let mut seeder = new_seeder();
/// let seeder = seeder.as_mut();
/// let mut encryption_generator =
/// EncryptionRandomGenerator::<ActivatedRandomGenerator>::new(seeder.seed(), seeder);
/// let mut secret_generator =
/// SecretRandomGenerator::<ActivatedRandomGenerator>::new(seeder.seed());
/// EncryptionRandomGenerator::<DefaultRandomGenerator>::new(seeder.seed(), seeder);
/// let mut secret_generator = SecretRandomGenerator::<DefaultRandomGenerator>::new(seeder.seed());
///
/// // Create the LweSecretKey
/// let input_lwe_secret_key =

12
tfhe/src/core_crypto/algorithms/lwe_packing_keyswitch_key_generation.rs
View File

@@ -7,7 +7,7 @@ use crate::core_crypto::algorithms::{
};
use crate::core_crypto::commons::generators::EncryptionRandomGenerator;
use crate::core_crypto::commons::math::decomposition::{DecompositionLevel, DecompositionTerm};
use crate::core_crypto::commons::math::random::{ActivatedRandomGenerator, Distribution, Uniform};
use crate::core_crypto::commons::math::random::{DefaultRandomGenerator, Distribution, Uniform};
use crate::core_crypto::commons::parameters::*;
use crate::core_crypto::commons::traits::*;
use crate::core_crypto::entities::{
@@ -38,9 +38,8 @@ use crate::core_crypto::entities::{
/// let mut seeder = new_seeder();
/// let seeder = seeder.as_mut();
/// let mut encryption_generator =
/// EncryptionRandomGenerator::<ActivatedRandomGenerator>::new(seeder.seed(), seeder);
/// let mut secret_generator =
/// SecretRandomGenerator::<ActivatedRandomGenerator>::new(seeder.seed());
/// EncryptionRandomGenerator::<DefaultRandomGenerator>::new(seeder.seed(), seeder);
/// let mut secret_generator = SecretRandomGenerator::<DefaultRandomGenerator>::new(seeder.seed());
///
/// // Create the LweSecretKey
/// let input_lwe_secret_key =
@@ -228,8 +227,7 @@ where
/// // Create the PRNG
/// let mut seeder = new_seeder();
/// let seeder = seeder.as_mut();
/// let mut secret_generator =
/// SecretRandomGenerator::<ActivatedRandomGenerator>::new(seeder.seed());
/// let mut secret_generator = SecretRandomGenerator::<DefaultRandomGenerator>::new(seeder.seed());
///
/// // Create the LweSecretKey
/// let input_lwe_secret_key =
@@ -317,7 +315,7 @@ pub fn generate_seeded_lwe_packing_keyswitch_key<
PlaintextCount(decomp_level_count.0 * polynomial_size.0),
);
let mut generator = EncryptionRandomGenerator::<ActivatedRandomGenerator>::new(
let mut generator = EncryptionRandomGenerator::<DefaultRandomGenerator>::new(
lwe_packing_keyswitch_key.compression_seed().seed,
noise_seeder,
);

24
tfhe/src/core_crypto/algorithms/lwe_private_functional_packing_keyswitch_key_generation.rs
View File

@@ -283,7 +283,7 @@ mod test {
// Create the PRNG
let mut seeder = new_seeder();
let mut secret_generator =
SecretRandomGenerator::<ActivatedRandomGenerator>::new(seeder.seed());
SecretRandomGenerator::<DefaultRandomGenerator>::new(seeder.seed());
let glwe_sk: GlweSecretKeyOwned<u64> = allocate_and_generate_new_binary_glwe_secret_key(
glwe_dimension,
@@ -293,12 +293,11 @@ mod test {
let lwe_big_sk = glwe_sk.clone().into_lwe_secret_key();
let mut seeder =
DeterministicSeeder::<ActivatedRandomGenerator>::new(common_encryption_seed);
let mut encryption_generator =
EncryptionRandomGenerator::<ActivatedRandomGenerator>::new(
seeder.seed(),
&mut seeder,
);
DeterministicSeeder::<DefaultRandomGenerator>::new(common_encryption_seed);
let mut encryption_generator = EncryptionRandomGenerator::<DefaultRandomGenerator>::new(
seeder.seed(),
&mut seeder,
);
let par_cbs_pfpksk = par_allocate_and_generate_new_circuit_bootstrap_lwe_pfpksk_list(
&lwe_big_sk,
@@ -311,12 +310,11 @@ mod test {
);
let mut seeder =
DeterministicSeeder::<ActivatedRandomGenerator>::new(common_encryption_seed);
let mut encryption_generator =
EncryptionRandomGenerator::<ActivatedRandomGenerator>::new(
seeder.seed(),
&mut seeder,
);
DeterministicSeeder::<DefaultRandomGenerator>::new(common_encryption_seed);
let mut encryption_generator = EncryptionRandomGenerator::<DefaultRandomGenerator>::new(
seeder.seed(),
&mut seeder,
);
let ser_cbs_pfpksk = allocate_and_generate_new_circuit_bootstrap_lwe_pfpksk_list(
&lwe_big_sk,

5
tfhe/src/core_crypto/algorithms/lwe_programmable_bootstrapping/fft128.rs
View File

@@ -49,13 +49,12 @@ use dyn_stack::{PodStack, SizeOverflow, StackReq};
/// let seeder = boxed_seeder.as_mut();
///
/// // Create a generator which uses a CSPRNG to generate secret keys
/// let mut secret_generator =
/// SecretRandomGenerator::<ActivatedRandomGenerator>::new(seeder.seed());
/// let mut secret_generator = SecretRandomGenerator::<DefaultRandomGenerator>::new(seeder.seed());
///
/// // Create a generator which uses two CSPRNGs to generate public masks and secret encryption
/// // noise
/// let mut encryption_generator =
/// EncryptionRandomGenerator::<ActivatedRandomGenerator>::new(seeder.seed(), seeder);
/// EncryptionRandomGenerator::<DefaultRandomGenerator>::new(seeder.seed(), seeder);
///
/// println!("Generating keys...");
///

20
tfhe/src/core_crypto/algorithms/lwe_programmable_bootstrapping/fft64.rs
View File

@@ -55,13 +55,12 @@ use tfhe_fft::c64;
/// let seeder = boxed_seeder.as_mut();
///
/// // Create a generator which uses a CSPRNG to generate secret keys
/// let mut secret_generator =
/// SecretRandomGenerator::<ActivatedRandomGenerator>::new(seeder.seed());
/// let mut secret_generator = SecretRandomGenerator::<DefaultRandomGenerator>::new(seeder.seed());
///
/// // Create a generator which uses two CSPRNGs to generate public masks and secret encryption
/// // noise
/// let mut encryption_generator =
/// EncryptionRandomGenerator::<ActivatedRandomGenerator>::new(seeder.seed(), seeder);
/// EncryptionRandomGenerator::<DefaultRandomGenerator>::new(seeder.seed(), seeder);
///
/// println!("Generating keys...");
///
@@ -343,9 +342,8 @@ pub fn add_external_product_assign<Scalar, OutputGlweCont, InputGlweCont, GgswCo
/// let mut seeder = new_seeder();
/// let seeder = seeder.as_mut();
/// let mut encryption_generator =
/// EncryptionRandomGenerator::<ActivatedRandomGenerator>::new(seeder.seed(), seeder);
/// let mut secret_generator =
/// SecretRandomGenerator::<ActivatedRandomGenerator>::new(seeder.seed());
/// EncryptionRandomGenerator::<DefaultRandomGenerator>::new(seeder.seed(), seeder);
/// let mut secret_generator = SecretRandomGenerator::<DefaultRandomGenerator>::new(seeder.seed());
///
/// // Create the GlweSecretKey
/// let glwe_secret_key = allocate_and_generate_new_binary_glwe_secret_key(
@@ -579,9 +577,8 @@ pub fn cmux_assign<Scalar, Cont0, Cont1, GgswCont>(
/// let mut seeder = new_seeder();
/// let seeder = seeder.as_mut();
/// let mut encryption_generator =
/// EncryptionRandomGenerator::<ActivatedRandomGenerator>::new(seeder.seed(), seeder);
/// let mut secret_generator =
/// SecretRandomGenerator::<ActivatedRandomGenerator>::new(seeder.seed());
/// EncryptionRandomGenerator::<DefaultRandomGenerator>::new(seeder.seed(), seeder);
/// let mut secret_generator = SecretRandomGenerator::<DefaultRandomGenerator>::new(seeder.seed());
///
/// // Create the GlweSecretKey
/// let glwe_secret_key = allocate_and_generate_new_binary_glwe_secret_key(
@@ -824,13 +821,12 @@ pub fn cmux_assign_mem_optimized_requirement<Scalar>(
/// let seeder = boxed_seeder.as_mut();
///
/// // Create a generator which uses a CSPRNG to generate secret keys
/// let mut secret_generator =
/// SecretRandomGenerator::<ActivatedRandomGenerator>::new(seeder.seed());
/// let mut secret_generator = SecretRandomGenerator::<DefaultRandomGenerator>::new(seeder.seed());
///
/// // Create a generator which uses two CSPRNGs to generate public masks and secret encryption
/// // noise
/// let mut encryption_generator =
/// EncryptionRandomGenerator::<ActivatedRandomGenerator>::new(seeder.seed(), seeder);
/// EncryptionRandomGenerator::<DefaultRandomGenerator>::new(seeder.seed(), seeder);
///
/// println!("Generating keys...");
///

10
tfhe/src/core_crypto/algorithms/lwe_programmable_bootstrapping/ntt64.rs
View File

@@ -56,13 +56,12 @@ use dyn_stack::{PodStack, SizeOverflow, StackReq};
/// let seeder = boxed_seeder.as_mut();
///
/// // Create a generator which uses a CSPRNG to generate secret keys
/// let mut secret_generator =
/// SecretRandomGenerator::<ActivatedRandomGenerator>::new(seeder.seed());
/// let mut secret_generator = SecretRandomGenerator::<DefaultRandomGenerator>::new(seeder.seed());
///
/// // Create a generator which uses two CSPRNGs to generate public masks and secret encryption
/// // noise
/// let mut encryption_generator =
/// EncryptionRandomGenerator::<ActivatedRandomGenerator>::new(seeder.seed(), seeder);
/// EncryptionRandomGenerator::<DefaultRandomGenerator>::new(seeder.seed(), seeder);
///
/// println!("Generating keys...");
///
@@ -312,13 +311,12 @@ pub fn blind_rotate_ntt64_assign_mem_optimized<InputCont, OutputCont, KeyCont>(
/// let seeder = boxed_seeder.as_mut();
///
/// // Create a generator which uses a CSPRNG to generate secret keys
/// let mut secret_generator =
/// SecretRandomGenerator::<ActivatedRandomGenerator>::new(seeder.seed());
/// let mut secret_generator = SecretRandomGenerator::<DefaultRandomGenerator>::new(seeder.seed());
///
/// // Create a generator which uses two CSPRNGs to generate public masks and secret encryption
/// // noise
/// let mut encryption_generator =
/// EncryptionRandomGenerator::<ActivatedRandomGenerator>::new(seeder.seed(), seeder);
/// EncryptionRandomGenerator::<DefaultRandomGenerator>::new(seeder.seed(), seeder);
///
/// println!("Generating keys...");
///

3
tfhe/src/core_crypto/algorithms/lwe_secret_key_generation.rs
View File

@@ -41,8 +41,7 @@ where
/// // Create the PRNG
/// let mut seeder = new_seeder();
/// let seeder = seeder.as_mut();
/// let mut secret_generator =
/// SecretRandomGenerator::<ActivatedRandomGenerator>::new(seeder.seed());
/// let mut secret_generator = SecretRandomGenerator::<DefaultRandomGenerator>::new(seeder.seed());
///
/// let mut lwe_secret_key = LweSecretKey::new_empty_key(0u64, lwe_dimension);
///

5
tfhe/src/core_crypto/algorithms/lwe_wopbs.rs
View File

@@ -437,9 +437,8 @@ pub fn extract_bits_from_lwe_ciphertext_mem_optimized_requirement<Scalar>(
/// let mut seeder = new_seeder();
/// let seeder = seeder.as_mut();
/// let mut encryption_generator =
/// EncryptionRandomGenerator::<ActivatedRandomGenerator>::new(seeder.seed(), seeder);
/// let mut secret_generator =
/// SecretRandomGenerator::<ActivatedRandomGenerator>::new(seeder.seed());
/// EncryptionRandomGenerator::<DefaultRandomGenerator>::new(seeder.seed(), seeder);
/// let mut secret_generator = SecretRandomGenerator::<DefaultRandomGenerator>::new(seeder.seed());
///
/// let glwe_sk = allocate_and_generate_new_binary_glwe_secret_key(
/// glwe_dimension,

15
tfhe/src/core_crypto/algorithms/test/ggsw_encryption.rs
View File

@@ -28,8 +28,7 @@ fn test_parallel_and_seeded_ggsw_encryption_equivalence<Scalar>(
let mut seeder = new_seeder();
let seeder = seeder.as_mut();
let main_seed = seeder.seed();
let mut secret_generator =
SecretRandomGenerator::<ActivatedRandomGenerator>::new(seeder.seed());
let mut secret_generator = SecretRandomGenerator::<DefaultRandomGenerator>::new(seeder.seed());
for _ in 0..NB_TESTS {
// Create the GlweSecretKey
@@ -55,9 +54,9 @@ fn test_parallel_and_seeded_ggsw_encryption_equivalence<Scalar>(
);
let mut deterministic_seeder =
DeterministicSeeder::<ActivatedRandomGenerator>::new(main_seed);
DeterministicSeeder::<DefaultRandomGenerator>::new(main_seed);
let mut encryption_generator = EncryptionRandomGenerator::<ActivatedRandomGenerator>::new(
let mut encryption_generator = EncryptionRandomGenerator::<DefaultRandomGenerator>::new(
compression_seed.seed,
&mut deterministic_seeder,
);
@@ -80,9 +79,9 @@ fn test_parallel_and_seeded_ggsw_encryption_equivalence<Scalar>(
);
let mut deterministic_seeder =
DeterministicSeeder::<ActivatedRandomGenerator>::new(main_seed);
DeterministicSeeder::<DefaultRandomGenerator>::new(main_seed);
let mut encryption_generator = EncryptionRandomGenerator::<ActivatedRandomGenerator>::new(
let mut encryption_generator = EncryptionRandomGenerator::<DefaultRandomGenerator>::new(
compression_seed.seed,
&mut deterministic_seeder,
);
@@ -109,7 +108,7 @@ fn test_parallel_and_seeded_ggsw_encryption_equivalence<Scalar>(
);
let mut deterministic_seeder =
DeterministicSeeder::<ActivatedRandomGenerator>::new(main_seed);
DeterministicSeeder::<DefaultRandomGenerator>::new(main_seed);
encrypt_constant_seeded_ggsw_ciphertext(
&glwe_secret_key,
@@ -130,7 +129,7 @@ fn test_parallel_and_seeded_ggsw_encryption_equivalence<Scalar>(
);
let mut deterministic_seeder =
DeterministicSeeder::<ActivatedRandomGenerator>::new(main_seed);
DeterministicSeeder::<DefaultRandomGenerator>::new(main_seed);
par_encrypt_constant_seeded_ggsw_ciphertext(
&glwe_secret_key,

14
tfhe/src/core_crypto/algorithms/test/lwe_bootstrap_key_generation.rs
View File

@@ -2,7 +2,7 @@ use crate::core_crypto::algorithms::*;
use crate::core_crypto::commons::dispersion::StandardDev;
use crate::core_crypto::commons::generators::{DeterministicSeeder, EncryptionRandomGenerator};
use crate::core_crypto::commons::math::random::{
ActivatedRandomGenerator, DynamicDistribution, Seed,
DefaultRandomGenerator, DynamicDistribution, Seed,
};
use crate::core_crypto::commons::math::torus::UnsignedTorus;
use crate::core_crypto::commons::parameters::{
@@ -59,9 +59,9 @@ fn test_parallel_and_seeded_bsk_gen_equivalence<T: UnsignedTorus + Sync + Send>(
ciphertext_modulus,
);
let mut encryption_generator = EncryptionRandomGenerator::<ActivatedRandomGenerator>::new(
let mut encryption_generator = EncryptionRandomGenerator::<DefaultRandomGenerator>::new(
mask_seed,
&mut DeterministicSeeder::<ActivatedRandomGenerator>::new(deterministic_seeder_seed),
&mut DeterministicSeeder::<DefaultRandomGenerator>::new(deterministic_seeder_seed),
);
par_generate_lwe_bootstrap_key(
@@ -82,9 +82,9 @@ fn test_parallel_and_seeded_bsk_gen_equivalence<T: UnsignedTorus + Sync + Send>(
ciphertext_modulus,
);
let mut encryption_generator = EncryptionRandomGenerator::<ActivatedRandomGenerator>::new(
let mut encryption_generator = EncryptionRandomGenerator::<DefaultRandomGenerator>::new(
mask_seed,
&mut DeterministicSeeder::<ActivatedRandomGenerator>::new(deterministic_seeder_seed),
&mut DeterministicSeeder::<DefaultRandomGenerator>::new(deterministic_seeder_seed),
);
generate_lwe_bootstrap_key(
@@ -113,7 +113,7 @@ fn test_parallel_and_seeded_bsk_gen_equivalence<T: UnsignedTorus + Sync + Send>(
&glwe_sk,
&mut sequential_seeded_bsk,
noise_distribution,
&mut DeterministicSeeder::<ActivatedRandomGenerator>::new(deterministic_seeder_seed),
&mut DeterministicSeeder::<DefaultRandomGenerator>::new(deterministic_seeder_seed),
);
let mut parallel_seeded_bsk = SeededLweBootstrapKey::new(
@@ -132,7 +132,7 @@ fn test_parallel_and_seeded_bsk_gen_equivalence<T: UnsignedTorus + Sync + Send>(
&glwe_sk,
&mut parallel_seeded_bsk,
noise_distribution,
&mut DeterministicSeeder::<ActivatedRandomGenerator>::new(deterministic_seeder_seed),
&mut DeterministicSeeder::<DefaultRandomGenerator>::new(deterministic_seeder_seed),
);
assert_eq!(sequential_seeded_bsk, parallel_seeded_bsk);

9
tfhe/src/core_crypto/algorithms/test/lwe_compact_public_key_generation.rs
View File

@@ -21,8 +21,7 @@ fn test_seeded_lwe_cpk_gen_equivalence<Scalar: UnsignedTorus>(
let seeder = seeder.as_mut();
let mask_seed = seeder.seed();
let deterministic_seeder_seed = seeder.seed();
let mut secret_generator =
SecretRandomGenerator::<ActivatedRandomGenerator>::new(seeder.seed());
let mut secret_generator = SecretRandomGenerator::<DefaultRandomGenerator>::new(seeder.seed());
for _ in 0..NB_TESTS {
// Create the LweSecretKey
@@ -32,8 +31,8 @@ fn test_seeded_lwe_cpk_gen_equivalence<Scalar: UnsignedTorus>(
let mut cpk = LweCompactPublicKey::new(Scalar::ZERO, lwe_dimension, ciphertext_modulus);
let mut deterministic_seeder =
DeterministicSeeder::<ActivatedRandomGenerator>::new(deterministic_seeder_seed);
let mut encryption_generator = EncryptionRandomGenerator::<ActivatedRandomGenerator>::new(
DeterministicSeeder::<DefaultRandomGenerator>::new(deterministic_seeder_seed);
let mut encryption_generator = EncryptionRandomGenerator::<DefaultRandomGenerator>::new(
mask_seed,
&mut deterministic_seeder,
);
@@ -58,7 +57,7 @@ fn test_seeded_lwe_cpk_gen_equivalence<Scalar: UnsignedTorus>(
);
let mut deterministic_seeder =
DeterministicSeeder::<ActivatedRandomGenerator>::new(deterministic_seeder_seed);
DeterministicSeeder::<DefaultRandomGenerator>::new(deterministic_seeder_seed);
generate_seeded_lwe_compact_public_key(
&input_lwe_secret_key,

40
tfhe/src/core_crypto/algorithms/test/lwe_encryption.rs
View File

@@ -27,8 +27,7 @@ fn parallel_and_seeded_lwe_list_encryption_equivalence<Scalar: UnsignedTorus + S
let main_seed = seeder.seed();
let mut secret_generator =
SecretRandomGenerator::<ActivatedRandomGenerator>::new(seeder.seed());
let mut secret_generator = SecretRandomGenerator::<DefaultRandomGenerator>::new(seeder.seed());
for _ in 0..NB_TESTS {
// Create the LweSecretKey
@@ -48,8 +47,8 @@ fn parallel_and_seeded_lwe_list_encryption_equivalence<Scalar: UnsignedTorus + S
);
let mut deterministic_seeder =
DeterministicSeeder::<ActivatedRandomGenerator>::new(main_seed);
let mut encryption_generator = EncryptionRandomGenerator::<ActivatedRandomGenerator>::new(
DeterministicSeeder::<DefaultRandomGenerator>::new(main_seed);
let mut encryption_generator = EncryptionRandomGenerator::<DefaultRandomGenerator>::new(
deterministic_seeder.seed(),
&mut deterministic_seeder,
);
@@ -69,8 +68,8 @@ fn parallel_and_seeded_lwe_list_encryption_equivalence<Scalar: UnsignedTorus + S
);
let mut deterministic_seeder =
DeterministicSeeder::<ActivatedRandomGenerator>::new(main_seed);
let mut encryption_generator = EncryptionRandomGenerator::<ActivatedRandomGenerator>::new(
DeterministicSeeder::<DefaultRandomGenerator>::new(main_seed);
let mut encryption_generator = EncryptionRandomGenerator::<DefaultRandomGenerator>::new(
deterministic_seeder.seed(),
&mut deterministic_seeder,
);
@@ -85,7 +84,7 @@ fn parallel_and_seeded_lwe_list_encryption_equivalence<Scalar: UnsignedTorus + S
assert_eq!(par_lwe_list, ser_lwe_list);
let mut deterministic_seeder =
DeterministicSeeder::<ActivatedRandomGenerator>::new(main_seed);
DeterministicSeeder::<DefaultRandomGenerator>::new(main_seed);
// Create a new LweCiphertextList
let mut par_seeded_lwe_list = SeededLweCiphertextList::new(
Scalar::ZERO,
@@ -104,7 +103,7 @@ fn parallel_and_seeded_lwe_list_encryption_equivalence<Scalar: UnsignedTorus + S
);
let mut deterministic_seeder =
DeterministicSeeder::<ActivatedRandomGenerator>::new(main_seed);
DeterministicSeeder::<DefaultRandomGenerator>::new(main_seed);
let mut ser_seeded_lwe_list = SeededLweCiphertextList::new(
Scalar::ZERO,
@@ -871,9 +870,8 @@ fn test_u128_encryption() {
let mut seeder = new_seeder();
let seeder = seeder.as_mut();
let mut encryption_generator =
EncryptionRandomGenerator::<ActivatedRandomGenerator>::new(seeder.seed(), seeder);
let mut secret_generator =
SecretRandomGenerator::<ActivatedRandomGenerator>::new(seeder.seed());
EncryptionRandomGenerator::<DefaultRandomGenerator>::new(seeder.seed(), seeder);
let mut secret_generator = SecretRandomGenerator::<DefaultRandomGenerator>::new(seeder.seed());
const MSG_BITS: u32 = 4;
@@ -1016,7 +1014,7 @@ fn lwe_compact_public_encrypt_prove_verify_decrypt_custom_mod<Scalar>(
let metadata = [b'c', b'o', b'r', b'e'];
let mut rsc = TestResources::new();
let mut random_generator = RandomGenerator::<ActivatedRandomGenerator>::new(rsc.seeder.seed());
let mut random_generator = RandomGenerator::<DefaultRandomGenerator>::new(rsc.seeder.seed());
let msg_modulus = Scalar::ONE.shl(message_modulus_log.0);
let mut msg = msg_modulus;
@@ -1160,14 +1158,13 @@ fn test_par_compact_lwe_list_public_key_encryption_and_proof() {
.collect::<Vec<_>>();
let par_lwe_ct_list = {
let mut deterministic_seeder =
DeterministicSeeder::<ActivatedRandomGenerator>::new(seed);
let mut deterministic_seeder = DeterministicSeeder::<DefaultRandomGenerator>::new(seed);
let mut random_generator =
RandomGenerator::<ActivatedRandomGenerator>::new(deterministic_seeder.seed());
RandomGenerator::<DefaultRandomGenerator>::new(deterministic_seeder.seed());
let mut secret_random_generator =
SecretRandomGenerator::<ActivatedRandomGenerator>::new(deterministic_seeder.seed());
SecretRandomGenerator::<DefaultRandomGenerator>::new(deterministic_seeder.seed());
let mut encryption_random_generator =
EncryptionRandomGenerator::<ActivatedRandomGenerator>::new(
EncryptionRandomGenerator::<DefaultRandomGenerator>::new(
deterministic_seeder.seed(),
&mut deterministic_seeder,
);
@@ -1252,14 +1249,13 @@ fn test_par_compact_lwe_list_public_key_encryption_and_proof() {
};
let ser_lwe_ct_list = {
let mut deterministic_seeder =
DeterministicSeeder::<ActivatedRandomGenerator>::new(seed);
let mut deterministic_seeder = DeterministicSeeder::<DefaultRandomGenerator>::new(seed);
let mut random_generator =
RandomGenerator::<ActivatedRandomGenerator>::new(deterministic_seeder.seed());
RandomGenerator::<DefaultRandomGenerator>::new(deterministic_seeder.seed());
let mut secret_random_generator =
SecretRandomGenerator::<ActivatedRandomGenerator>::new(deterministic_seeder.seed());
SecretRandomGenerator::<DefaultRandomGenerator>::new(deterministic_seeder.seed());
let mut encryption_random_generator =
EncryptionRandomGenerator::<ActivatedRandomGenerator>::new(
EncryptionRandomGenerator::<DefaultRandomGenerator>::new(
deterministic_seeder.seed(),
&mut deterministic_seeder,
);

9
tfhe/src/core_crypto/algorithms/test/lwe_keyswitch_key_generation.rs
View File

@@ -24,8 +24,7 @@ fn test_seeded_lwe_ksk_gen_equivalence<Scalar: UnsignedTorus + Send + Sync>(
let seeder = seeder.as_mut();
let mask_seed = seeder.seed();
let deterministic_seeder_seed = seeder.seed();
let mut secret_generator =
SecretRandomGenerator::<ActivatedRandomGenerator>::new(seeder.seed());
let mut secret_generator = SecretRandomGenerator::<DefaultRandomGenerator>::new(seeder.seed());
for _ in 0..NB_TESTS {
// Create the LweSecretKey
@@ -48,8 +47,8 @@ fn test_seeded_lwe_ksk_gen_equivalence<Scalar: UnsignedTorus + Send + Sync>(
);
let mut deterministic_seeder =
DeterministicSeeder::<ActivatedRandomGenerator>::new(deterministic_seeder_seed);
let mut encryption_generator = EncryptionRandomGenerator::<ActivatedRandomGenerator>::new(
DeterministicSeeder::<DefaultRandomGenerator>::new(deterministic_seeder_seed);
let mut encryption_generator = EncryptionRandomGenerator::<DefaultRandomGenerator>::new(
mask_seed,
&mut deterministic_seeder,
);
@@ -78,7 +77,7 @@ fn test_seeded_lwe_ksk_gen_equivalence<Scalar: UnsignedTorus + Send + Sync>(
);
let mut deterministic_seeder =
DeterministicSeeder::<ActivatedRandomGenerator>::new(deterministic_seeder_seed);
DeterministicSeeder::<DefaultRandomGenerator>::new(deterministic_seeder_seed);
generate_seeded_lwe_keyswitch_key(
&input_lwe_secret_key,

14
tfhe/src/core_crypto/algorithms/test/lwe_multi_bit_bootstrap_key_generation.rs
View File

@@ -2,7 +2,7 @@ use crate::core_crypto::algorithms::*;
use crate::core_crypto::commons::dispersion::StandardDev;
use crate::core_crypto::commons::generators::{DeterministicSeeder, EncryptionRandomGenerator};
use crate::core_crypto::commons::math::random::{
ActivatedRandomGenerator, DynamicDistribution, Seed,
DefaultRandomGenerator, DynamicDistribution, Seed,
};
use crate::core_crypto::commons::math::torus::UnsignedTorus;
use crate::core_crypto::commons::parameters::{
@@ -70,9 +70,9 @@ fn test_parallel_and_seeded_multi_bit_bsk_gen_equivalence<
ciphertext_modulus,
);
let mut encryption_generator = EncryptionRandomGenerator::<ActivatedRandomGenerator>::new(
let mut encryption_generator = EncryptionRandomGenerator::<DefaultRandomGenerator>::new(
mask_seed,
&mut DeterministicSeeder::<ActivatedRandomGenerator>::new(deterministic_seeder_seed),
&mut DeterministicSeeder::<DefaultRandomGenerator>::new(deterministic_seeder_seed),
);
par_generate_lwe_multi_bit_bootstrap_key(
@@ -94,9 +94,9 @@ fn test_parallel_and_seeded_multi_bit_bsk_gen_equivalence<
ciphertext_modulus,
);
let mut encryption_generator = EncryptionRandomGenerator::<ActivatedRandomGenerator>::new(
let mut encryption_generator = EncryptionRandomGenerator::<DefaultRandomGenerator>::new(
mask_seed,
&mut DeterministicSeeder::<ActivatedRandomGenerator>::new(deterministic_seeder_seed),
&mut DeterministicSeeder::<DefaultRandomGenerator>::new(deterministic_seeder_seed),
);
generate_lwe_multi_bit_bootstrap_key(
@@ -126,7 +126,7 @@ fn test_parallel_and_seeded_multi_bit_bsk_gen_equivalence<
&glwe_sk,
&mut sequential_seeded_multi_bit_bsk,
noise_distribution,
&mut DeterministicSeeder::<ActivatedRandomGenerator>::new(deterministic_seeder_seed),
&mut DeterministicSeeder::<DefaultRandomGenerator>::new(deterministic_seeder_seed),
);
let mut parallel_seeded_multi_bit_bsk = SeededLweMultiBitBootstrapKey::new(
@@ -146,7 +146,7 @@ fn test_parallel_and_seeded_multi_bit_bsk_gen_equivalence<
&glwe_sk,
&mut parallel_seeded_multi_bit_bsk,
noise_distribution,
&mut DeterministicSeeder::<ActivatedRandomGenerator>::new(deterministic_seeder_seed),
&mut DeterministicSeeder::<DefaultRandomGenerator>::new(deterministic_seeder_seed),
);
assert_eq!(

9
tfhe/src/core_crypto/algorithms/test/lwe_packing_keyswitch_key_generation.rs
View File

@@ -26,8 +26,7 @@ fn test_seeded_lwe_pksk_gen_equivalence<Scalar: UnsignedTorus>(
let seeder = seeder.as_mut();
let mask_seed = seeder.seed();
let deterministic_seeder_seed = seeder.seed();
let mut secret_generator =
SecretRandomGenerator::<ActivatedRandomGenerator>::new(seeder.seed());
let mut secret_generator = SecretRandomGenerator::<DefaultRandomGenerator>::new(seeder.seed());
for _ in 0..NB_TESTS {
// Create the LweSecretKey
@@ -52,8 +51,8 @@ fn test_seeded_lwe_pksk_gen_equivalence<Scalar: UnsignedTorus>(
);
let mut deterministic_seeder =
DeterministicSeeder::<ActivatedRandomGenerator>::new(deterministic_seeder_seed);
let mut encryption_generator = EncryptionRandomGenerator::<ActivatedRandomGenerator>::new(
DeterministicSeeder::<DefaultRandomGenerator>::new(deterministic_seeder_seed);
let mut encryption_generator = EncryptionRandomGenerator::<DefaultRandomGenerator>::new(
mask_seed,
&mut deterministic_seeder,
);
@@ -83,7 +82,7 @@ fn test_seeded_lwe_pksk_gen_equivalence<Scalar: UnsignedTorus>(
);
let mut deterministic_seeder =
DeterministicSeeder::<ActivatedRandomGenerator>::new(deterministic_seeder_seed);
DeterministicSeeder::<DefaultRandomGenerator>::new(deterministic_seeder_seed);
generate_seeded_lwe_packing_keyswitch_key(
&input_lwe_secret_key,

4
tfhe/src/core_crypto/algorithms/test/mod.rs
View File

@@ -28,8 +28,8 @@ mod noise_distribution;
pub struct TestResources {
pub seeder: Box<dyn Seeder>,
pub encryption_random_generator: EncryptionRandomGenerator<ActivatedRandomGenerator>,
pub secret_random_generator: SecretRandomGenerator<ActivatedRandomGenerator>,
pub encryption_random_generator: EncryptionRandomGenerator<DefaultRandomGenerator>,
pub secret_random_generator: SecretRandomGenerator<DefaultRandomGenerator>,
}
impl TestResources {

4
tfhe/src/core_crypto/commons/math/random/mod.rs
View File

@@ -19,11 +19,10 @@ use crate::core_crypto::commons::numeric::{FloatingPoint, UnsignedInteger};
use std::ops::Bound;
use crate::core_crypto::prelude::{CastInto, Numeric};
/// Convenience alias for the most efficient CSPRNG implementation available.
pub use activated_random_generator::ActivatedRandomGenerator;
pub use gaussian::*;
pub use generator::*;
pub use t_uniform::*;
pub use tfhe_csprng::generators::DefaultRandomGenerator;
use tfhe_versionable::Versionize;
pub use uniform::*;
pub use uniform_binary::*;
@@ -32,7 +31,6 @@ pub use uniform_ternary::*;
#[cfg(test)]
mod tests;
mod activated_random_generator;
mod gaussian;
mod generator;
mod t_uniform;

9
tfhe/src/core_crypto/commons/mod.rs
View File

@@ -36,7 +36,7 @@ pub mod test_tools {
EncryptionRandomGenerator, SecretRandomGenerator,
};
use crate::core_crypto::commons::math::random::{
ActivatedRandomGenerator, RandomGenerable, RandomGenerator, Uniform,
DefaultRandomGenerator, RandomGenerable, RandomGenerator, Uniform,
};
use crate::core_crypto::commons::parameters::{
CiphertextCount, DecompositionBaseLog, DecompositionLevelCount, GlweDimension,
@@ -53,16 +53,15 @@ pub mod test_tools {
)
}
pub fn new_random_generator() -> RandomGenerator<ActivatedRandomGenerator> {
pub fn new_random_generator() -> RandomGenerator<DefaultRandomGenerator> {
RandomGenerator::new(random_seed())
}
pub fn new_secret_random_generator() -> SecretRandomGenerator<ActivatedRandomGenerator> {
pub fn new_secret_random_generator() -> SecretRandomGenerator<DefaultRandomGenerator> {
SecretRandomGenerator::new(random_seed())
}
pub fn new_encryption_random_generator() -> EncryptionRandomGenerator<ActivatedRandomGenerator>
{
pub fn new_encryption_random_generator() -> EncryptionRandomGenerator<DefaultRandomGenerator> {
EncryptionRandomGenerator::new(random_seed(), &mut UnsafeRandSeeder)
}

4
tfhe/src/core_crypto/entities/compressed_modulus_switched_glwe_ciphertext.rs
View File

@@ -25,7 +25,7 @@ use crate::core_crypto::prelude::*;
/// Gaussian::from_dispersion_parameter(StandardDev(0.00000000000000029403601535432533), 0.0);
/// let ciphertext_modulus = CiphertextModulus::new_native();
///
/// let mut secret_generator = SecretRandomGenerator::<ActivatedRandomGenerator>::new(Seed(0));
/// let mut secret_generator = SecretRandomGenerator::<DefaultRandomGenerator>::new(Seed(0));
///
/// let glwe_secret_key = allocate_and_generate_new_binary_glwe_secret_key::<u64, _>(
/// glwe_size.to_glwe_dimension(),
@@ -37,7 +37,7 @@ use crate::core_crypto::prelude::*;
/// let seeder = seeder.as_mut();
///
/// let mut encryption_generator =
/// EncryptionRandomGenerator::<ActivatedRandomGenerator>::new(seeder.seed(), seeder);
/// EncryptionRandomGenerator::<DefaultRandomGenerator>::new(seeder.seed(), seeder);
///
/// let inputs = [1 << 57, 1 << 58];
///

4
tfhe/src/core_crypto/entities/compressed_modulus_switched_lwe_ciphertext.rs
View File

@@ -20,7 +20,7 @@ use crate::core_crypto::prelude::*;
///
/// let log_modulus = 12;
///
/// let mut secret_generator = SecretRandomGenerator::<ActivatedRandomGenerator>::new(Seed(0));
/// let mut secret_generator = SecretRandomGenerator::<DefaultRandomGenerator>::new(Seed(0));
///
/// // Create the LweSecretKey
/// let lwe_secret_key = allocate_and_generate_new_binary_lwe_secret_key::<u64, _>(
@@ -33,7 +33,7 @@ use crate::core_crypto::prelude::*;
/// let seeder = seeder.as_mut();
///
/// let mut encryption_generator =
/// EncryptionRandomGenerator::<ActivatedRandomGenerator>::new(seeder.seed(), seeder);
/// EncryptionRandomGenerator::<DefaultRandomGenerator>::new(seeder.seed(), seeder);
///
/// // Unsecure parameters, do not use them
/// let lwe = allocate_and_encrypt_new_lwe_ciphertext(

5
tfhe/src/core_crypto/entities/compressed_modulus_switched_multi_bit_lwe_ciphertext.rs
View File

@@ -35,13 +35,12 @@ use tfhe_versionable::Versionize;
/// let seeder = boxed_seeder.as_mut();
///
/// // Create a generator which uses a CSPRNG to generate secret keys
/// let mut secret_generator =
/// SecretRandomGenerator::<ActivatedRandomGenerator>::new(seeder.seed());
/// let mut secret_generator = SecretRandomGenerator::<DefaultRandomGenerator>::new(seeder.seed());
///
/// // Create a generator which uses two CSPRNGs to generate public masks and secret encryption
/// // noise
/// let mut encryption_generator =
/// EncryptionRandomGenerator::<ActivatedRandomGenerator>::new(seeder.seed(), seeder);
/// EncryptionRandomGenerator::<DefaultRandomGenerator>::new(seeder.seed(), seeder);
///
/// // Generate an LweSecretKey with binary coefficients
/// let small_lwe_sk =

3
tfhe/src/core_crypto/entities/glwe_secret_key.rs
View File

@@ -206,8 +206,7 @@ where
/// // Create the PRNG
/// let mut seeder = new_seeder();
/// let seeder = seeder.as_mut();
/// let mut secret_generator =
/// SecretRandomGenerator::<ActivatedRandomGenerator>::new(seeder.seed());
/// let mut secret_generator = SecretRandomGenerator::<DefaultRandomGenerator>::new(seeder.seed());
///
/// let glwe_secret_key: GlweSecretKeyOwned<u64> = GlweSecretKey::generate_new_binary(
/// glwe_size.to_glwe_dimension(),

3
tfhe/src/core_crypto/entities/lwe_secret_key.rs
View File

@@ -154,8 +154,7 @@ where
/// // Create the PRNG
/// let mut seeder = new_seeder();
/// let seeder = seeder.as_mut();
/// let mut secret_generator =
/// SecretRandomGenerator::<ActivatedRandomGenerator>::new(seeder.seed());
/// let mut secret_generator = SecretRandomGenerator::<DefaultRandomGenerator>::new(seeder.seed());
///
/// let lwe_secret_key: LweSecretKeyOwned<u64> =
/// LweSecretKey::generate_new_binary(lwe_dimension, &mut secret_generator);

6
tfhe/src/core_crypto/entities/seeded_ggsw_ciphertext.rs
View File

@@ -8,7 +8,7 @@ use crate::core_crypto::commons::generators::{
EncryptionRandomGeneratorForkConfig, MaskRandomGeneratorForkConfig,
};
use crate::core_crypto::commons::math::random::{
ActivatedRandomGenerator, CompressionSeed, Distribution, RandomGenerable,
CompressionSeed, DefaultRandomGenerator, Distribution, RandomGenerable,
};
use crate::core_crypto::commons::parameters::*;
use crate::core_crypto::commons::traits::*;
@@ -280,7 +280,7 @@ impl<Scalar: UnsignedInteger, C: Container<Element = Scalar>> SeededGgswCipherte
self.decomposition_level_count(),
self.ciphertext_modulus(),
);
decompress_seeded_ggsw_ciphertext::<_, _, _, ActivatedRandomGenerator>(
decompress_seeded_ggsw_ciphertext::<_, _, _, DefaultRandomGenerator>(
&mut decompressed_ct,
&self,
);
@@ -301,7 +301,7 @@ impl<Scalar: UnsignedInteger, C: Container<Element = Scalar>> SeededGgswCipherte
self.decomposition_level_count(),
self.ciphertext_modulus(),
);
par_decompress_seeded_ggsw_ciphertext::<_, _, _, ActivatedRandomGenerator>(
par_decompress_seeded_ggsw_ciphertext::<_, _, _, DefaultRandomGenerator>(
&mut decompressed_ct,
&self,
);

6
tfhe/src/core_crypto/entities/seeded_ggsw_ciphertext_list.rs
View File

@@ -7,7 +7,7 @@ use crate::core_crypto::commons::generators::{
EncryptionRandomGeneratorForkConfig, MaskRandomGeneratorForkConfig,
};
use crate::core_crypto::commons::math::random::{
ActivatedRandomGenerator, CompressionSeed, Distribution, RandomGenerable,
CompressionSeed, DefaultRandomGenerator, Distribution, RandomGenerable,
};
use crate::core_crypto::commons::parameters::*;
use crate::core_crypto::commons::traits::*;
@@ -243,7 +243,7 @@ impl<Scalar: UnsignedInteger, C: Container<Element = Scalar>> SeededGgswCipherte
self.ggsw_ciphertext_count(),
self.ciphertext_modulus(),
);
decompress_seeded_ggsw_ciphertext_list::<_, _, _, ActivatedRandomGenerator>(
decompress_seeded_ggsw_ciphertext_list::<_, _, _, DefaultRandomGenerator>(
&mut decompressed_list,
&self,
);
@@ -265,7 +265,7 @@ impl<Scalar: UnsignedInteger, C: Container<Element = Scalar>> SeededGgswCipherte
self.ggsw_ciphertext_count(),
self.ciphertext_modulus(),
);
par_decompress_seeded_ggsw_ciphertext_list::<_, _, _, ActivatedRandomGenerator>(
par_decompress_seeded_ggsw_ciphertext_list::<_, _, _, DefaultRandomGenerator>(
&mut decompressed_list,
&self,
);

4
tfhe/src/core_crypto/entities/seeded_glwe_ciphertext.rs
View File

@@ -6,7 +6,7 @@ use tfhe_versionable::Versionize;
use crate::conformance::ParameterSetConformant;
use crate::core_crypto::algorithms::*;
use crate::core_crypto::backward_compatibility::entities::seeded_glwe_ciphertext::SeededGlweCiphertextVersions;
use crate::core_crypto::commons::math::random::{ActivatedRandomGenerator, CompressionSeed};
use crate::core_crypto::commons::math::random::{CompressionSeed, DefaultRandomGenerator};
use crate::core_crypto::commons::parameters::*;
use crate::core_crypto::commons::traits::*;
use crate::core_crypto::entities::*;
@@ -201,7 +201,7 @@ impl<Scalar: UnsignedInteger, C: Container<Element = Scalar>> SeededGlweCipherte
self.polynomial_size(),
self.ciphertext_modulus(),
);
decompress_seeded_glwe_ciphertext::<_, _, _, ActivatedRandomGenerator>(
decompress_seeded_glwe_ciphertext::<_, _, _, DefaultRandomGenerator>(
&mut decompressed_ct,
&self,
);

4
tfhe/src/core_crypto/entities/seeded_glwe_ciphertext_list.rs
View File

@@ -4,7 +4,7 @@ use tfhe_versionable::Versionize;
use crate::core_crypto::algorithms::*;
use crate::core_crypto::backward_compatibility::entities::seeded_glwe_ciphertext_list::SeededGlweCiphertextListVersions;
use crate::core_crypto::commons::math::random::{ActivatedRandomGenerator, CompressionSeed};
use crate::core_crypto::commons::math::random::{CompressionSeed, DefaultRandomGenerator};
use crate::core_crypto::commons::parameters::*;
use crate::core_crypto::commons::traits::*;
use crate::core_crypto::entities::*;
@@ -188,7 +188,7 @@ impl<Scalar: UnsignedInteger, C: Container<Element = Scalar>> SeededGlweCipherte
self.glwe_ciphertext_count(),
self.ciphertext_modulus(),
);
decompress_seeded_glwe_ciphertext_list::<_, _, _, ActivatedRandomGenerator>(
decompress_seeded_glwe_ciphertext_list::<_, _, _, DefaultRandomGenerator>(
&mut decompressed_list,
&self,
);

6
tfhe/src/core_crypto/entities/seeded_lwe_bootstrap_key.rs
View File

@@ -5,7 +5,7 @@ use tfhe_versionable::Versionize;
use crate::conformance::ParameterSetConformant;
use crate::core_crypto::algorithms::*;
use crate::core_crypto::backward_compatibility::entities::seeded_lwe_bootstrap_key::SeededLweBootstrapKeyVersions;
use crate::core_crypto::commons::math::random::{ActivatedRandomGenerator, CompressionSeed};
use crate::core_crypto::commons::math::random::{CompressionSeed, DefaultRandomGenerator};
use crate::core_crypto::commons::parameters::*;
use crate::core_crypto::commons::traits::*;
use crate::core_crypto::entities::*;
@@ -217,7 +217,7 @@ impl<Scalar: UnsignedInteger, C: Container<Element = Scalar>> SeededLweBootstrap
self.input_lwe_dimension(),
self.ciphertext_modulus(),
);
decompress_seeded_lwe_bootstrap_key::<_, _, _, ActivatedRandomGenerator>(
decompress_seeded_lwe_bootstrap_key::<_, _, _, DefaultRandomGenerator>(
&mut decompressed_bsk,
&self,
);
@@ -239,7 +239,7 @@ impl<Scalar: UnsignedInteger, C: Container<Element = Scalar>> SeededLweBootstrap
self.input_lwe_dimension(),
self.ciphertext_modulus(),
);
par_decompress_seeded_lwe_bootstrap_key::<_, _, _, ActivatedRandomGenerator>(
par_decompress_seeded_lwe_bootstrap_key::<_, _, _, DefaultRandomGenerator>(
&mut decompressed_bsk,
&self,
);

4
tfhe/src/core_crypto/entities/seeded_lwe_ciphertext.rs
View File

@@ -5,7 +5,7 @@ use tfhe_versionable::Versionize;
use crate::conformance::ParameterSetConformant;
use crate::core_crypto::algorithms::*;
use crate::core_crypto::backward_compatibility::entities::seeded_lwe_ciphertext::SeededLweCiphertextVersions;
use crate::core_crypto::commons::math::random::{ActivatedRandomGenerator, CompressionSeed};
use crate::core_crypto::commons::math::random::{CompressionSeed, DefaultRandomGenerator};
use crate::core_crypto::commons::parameters::*;
use crate::core_crypto::commons::traits::*;
use crate::core_crypto::entities::*;
@@ -173,7 +173,7 @@ impl<Scalar: UnsignedInteger> SeededLweCiphertext<Scalar> {
{
let mut decompressed_ct =
LweCiphertext::new(Scalar::ZERO, self.lwe_size(), self.ciphertext_modulus());
decompress_seeded_lwe_ciphertext::<_, _, ActivatedRandomGenerator>(
decompress_seeded_lwe_ciphertext::<_, _, DefaultRandomGenerator>(
&mut decompressed_ct,
&self,
);

6
tfhe/src/core_crypto/entities/seeded_lwe_ciphertext_list.rs
View File

@@ -8,7 +8,7 @@ use crate::core_crypto::commons::generators::{
EncryptionRandomGeneratorForkConfig, MaskRandomGeneratorForkConfig,
};
use crate::core_crypto::commons::math::random::{
ActivatedRandomGenerator, CompressionSeed, Distribution, RandomGenerable,
CompressionSeed, DefaultRandomGenerator, Distribution, RandomGenerable,
};
use crate::core_crypto::commons::parameters::*;
use crate::core_crypto::commons::traits::*;
@@ -164,7 +164,7 @@ impl<Scalar: UnsignedInteger, C: Container<Element = Scalar>> SeededLweCiphertex
self.lwe_ciphertext_count(),
self.ciphertext_modulus(),
);
decompress_seeded_lwe_ciphertext_list::<_, _, _, ActivatedRandomGenerator>(
decompress_seeded_lwe_ciphertext_list::<_, _, _, DefaultRandomGenerator>(
&mut decompressed_list,
&self,
);
@@ -183,7 +183,7 @@ impl<Scalar: UnsignedInteger, C: Container<Element = Scalar>> SeededLweCiphertex
self.lwe_ciphertext_count(),
self.ciphertext_modulus(),
);
par_decompress_seeded_lwe_ciphertext_list::<_, _, _, ActivatedRandomGenerator>(
par_decompress_seeded_lwe_ciphertext_list::<_, _, _, DefaultRandomGenerator>(
&mut decompressed_list,
&self,
);

4
tfhe/src/core_crypto/entities/seeded_lwe_compact_public_key.rs
View File

@@ -5,7 +5,7 @@ use tfhe_versionable::Versionize;
use crate::conformance::ParameterSetConformant;
use crate::core_crypto::algorithms::decompress_seeded_lwe_compact_public_key;
use crate::core_crypto::backward_compatibility::entities::seeded_lwe_compact_public_key::SeededLweCompactPublicKeyVersions;
use crate::core_crypto::commons::math::random::{ActivatedRandomGenerator, CompressionSeed};
use crate::core_crypto::commons::math::random::{CompressionSeed, DefaultRandomGenerator};
use crate::core_crypto::commons::parameters::*;
use crate::core_crypto::commons::traits::*;
use crate::core_crypto::entities::*;
@@ -179,7 +179,7 @@ impl<Scalar: UnsignedInteger, C: Container<Element = Scalar>> SeededLweCompactPu
self.lwe_dimension(),
self.ciphertext_modulus(),
);
decompress_seeded_lwe_compact_public_key::<_, _, _, ActivatedRandomGenerator>(
decompress_seeded_lwe_compact_public_key::<_, _, _, DefaultRandomGenerator>(
&mut decompressed_cpk,
&self,
);

6
tfhe/src/core_crypto/entities/seeded_lwe_keyswitch_key.rs
View File

@@ -3,7 +3,7 @@
use crate::conformance::ParameterSetConformant;
use crate::core_crypto::algorithms::*;
use crate::core_crypto::backward_compatibility::entities::seeded_lwe_keyswitch_key::SeededLweKeyswitchKeyVersions;
use crate::core_crypto::commons::math::random::{ActivatedRandomGenerator, CompressionSeed};
use crate::core_crypto::commons::math::random::{CompressionSeed, DefaultRandomGenerator};
use crate::core_crypto::commons::parameters::*;
use crate::core_crypto::commons::traits::*;
use crate::core_crypto::entities::*;
@@ -251,7 +251,7 @@ impl<Scalar: UnsignedInteger, C: Container<Element = Scalar>> SeededLweKeyswitch
self.output_key_lwe_dimension(),
self.ciphertext_modulus(),
);
decompress_seeded_lwe_keyswitch_key::<_, _, _, ActivatedRandomGenerator>(
decompress_seeded_lwe_keyswitch_key::<_, _, _, DefaultRandomGenerator>(
&mut decompressed_ksk,
&self,
);
@@ -272,7 +272,7 @@ impl<Scalar: UnsignedInteger, C: Container<Element = Scalar>> SeededLweKeyswitch
self.output_key_lwe_dimension(),
self.ciphertext_modulus(),
);
par_decompress_seeded_lwe_keyswitch_key::<_, _, _, ActivatedRandomGenerator>(
par_decompress_seeded_lwe_keyswitch_key::<_, _, _, DefaultRandomGenerator>(
&mut decompressed_ksk,
&self,
);

6
tfhe/src/core_crypto/entities/seeded_lwe_multi_bit_bootstrap_key.rs
View File

@@ -7,7 +7,7 @@ use crate::core_crypto::commons::generators::{
EncryptionRandomGeneratorForkConfig, MaskRandomGeneratorForkConfig,
};
use crate::core_crypto::commons::math::random::{
ActivatedRandomGenerator, CompressionSeed, Distribution, RandomGenerable,
CompressionSeed, DefaultRandomGenerator, Distribution, RandomGenerable,
};
use crate::core_crypto::commons::parameters::*;
use crate::core_crypto::commons::traits::*;
@@ -272,7 +272,7 @@ impl<Scalar: UnsignedInteger, C: Container<Element = Scalar>> SeededLweMultiBitB
self.grouping_factor(),
self.ciphertext_modulus(),
);
decompress_seeded_lwe_multi_bit_bootstrap_key::<_, _, _, ActivatedRandomGenerator>(
decompress_seeded_lwe_multi_bit_bootstrap_key::<_, _, _, DefaultRandomGenerator>(
&mut decompressed_bsk,
&self,
);
@@ -297,7 +297,7 @@ impl<Scalar: UnsignedInteger, C: Container<Element = Scalar>> SeededLweMultiBitB
self.grouping_factor(),
self.ciphertext_modulus(),
);
par_decompress_seeded_lwe_multi_bit_bootstrap_key::<_, _, _, ActivatedRandomGenerator>(
par_decompress_seeded_lwe_multi_bit_bootstrap_key::<_, _, _, DefaultRandomGenerator>(
&mut decompressed_bsk,
&self,
);

4
tfhe/src/core_crypto/entities/seeded_lwe_packing_keyswitch_key.rs
View File

@@ -3,7 +3,7 @@
use crate::conformance::ParameterSetConformant;
use crate::core_crypto::algorithms::*;
use crate::core_crypto::backward_compatibility::entities::seeded_lwe_packing_keyswitch_key::SeededLwePackingKeyswitchKeyVersions;
use crate::core_crypto::commons::math::random::{ActivatedRandomGenerator, CompressionSeed};
use crate::core_crypto::commons::math::random::{CompressionSeed, DefaultRandomGenerator};
use crate::core_crypto::commons::parameters::*;
use crate::core_crypto::commons::traits::*;
use crate::core_crypto::entities::*;
@@ -296,7 +296,7 @@ impl<Scalar: UnsignedInteger, C: Container<Element = Scalar>> SeededLwePackingKe
self.output_key_polynomial_size(),
self.ciphertext_modulus(),
);
decompress_seeded_lwe_packing_keyswitch_key::<_, _, _, ActivatedRandomGenerator>(
decompress_seeded_lwe_packing_keyswitch_key::<_, _, _, DefaultRandomGenerator>(
&mut decompressed_pksk,
&self,
);

6
tfhe/src/core_crypto/entities/seeded_lwe_public_key.rs
View File

@@ -4,7 +4,7 @@ use tfhe_versionable::Versionize;
use crate::core_crypto::algorithms::*;
use crate::core_crypto::backward_compatibility::entities::seeded_lwe_public_key::SeededLwePublicKeyVersions;
use crate::core_crypto::commons::math::random::{ActivatedRandomGenerator, CompressionSeed};
use crate::core_crypto::commons::math::random::{CompressionSeed, DefaultRandomGenerator};
use crate::core_crypto::commons::parameters::*;
use crate::core_crypto::commons::traits::*;
use crate::core_crypto::entities::*;
@@ -186,7 +186,7 @@ impl<Scalar: UnsignedInteger, C: Container<Element = Scalar>> SeededLwePublicKey
self.zero_encryption_count(),
self.ciphertext_modulus(),
);
decompress_seeded_lwe_public_key::<_, _, _, ActivatedRandomGenerator>(
decompress_seeded_lwe_public_key::<_, _, _, DefaultRandomGenerator>(
&mut decompressed_public_key,
&self,
);
@@ -207,7 +207,7 @@ impl<Scalar: UnsignedInteger, C: Container<Element = Scalar>> SeededLwePublicKey
self.zero_encryption_count(),
self.ciphertext_modulus(),
);
par_decompress_seeded_lwe_public_key::<_, _, _, ActivatedRandomGenerator>(
par_decompress_seeded_lwe_public_key::<_, _, _, DefaultRandomGenerator>(
&mut decompressed_public_key,
&self,
);

5
tfhe/src/core_crypto/experimental/algorithms/glwe_fast_keyswitch.rs
View File

@@ -52,9 +52,8 @@ use tfhe_fft::c64;
/// let mut seeder = new_seeder();
/// let seeder = seeder.as_mut();
/// let mut encryption_generator =
/// EncryptionRandomGenerator::<ActivatedRandomGenerator>::new(seeder.seed(), seeder);
/// let mut secret_generator =
/// SecretRandomGenerator::<ActivatedRandomGenerator>::new(seeder.seed());
/// EncryptionRandomGenerator::<DefaultRandomGenerator>::new(seeder.seed(), seeder);
/// let mut secret_generator = SecretRandomGenerator::<DefaultRandomGenerator>::new(seeder.seed());
///
/// // Create the GlweSecretKey
/// let glwe_secret_key_out = allocate_and_generate_new_binary_glwe_secret_key(

10
tfhe/src/core_crypto/experimental/algorithms/glwe_partial_sample_extraction.rs
View File

@@ -35,9 +35,8 @@ use crate::core_crypto::entities::*;
/// let mut seeder = new_seeder();
/// let seeder = seeder.as_mut();
/// let mut encryption_generator =
/// EncryptionRandomGenerator::<ActivatedRandomGenerator>::new(seeder.seed(), seeder);
/// let mut secret_generator =
/// SecretRandomGenerator::<ActivatedRandomGenerator>::new(seeder.seed());
/// EncryptionRandomGenerator::<DefaultRandomGenerator>::new(seeder.seed(), seeder);
/// let mut secret_generator = SecretRandomGenerator::<DefaultRandomGenerator>::new(seeder.seed());
///
/// // Create the GlweSecretKey
/// let glwe_secret_key = allocate_and_generate_new_partial_binary_glwe_secret_key(
@@ -187,9 +186,8 @@ pub fn partial_extract_lwe_sample_from_glwe_ciphertext<Scalar, InputCont, Output
/// let mut seeder = new_seeder();
/// let seeder = seeder.as_mut();
/// let mut encryption_generator =
/// EncryptionRandomGenerator::<ActivatedRandomGenerator>::new(seeder.seed(), seeder);
/// let mut secret_generator =
/// SecretRandomGenerator::<ActivatedRandomGenerator>::new(seeder.seed());
/// EncryptionRandomGenerator::<DefaultRandomGenerator>::new(seeder.seed(), seeder);
/// let mut secret_generator = SecretRandomGenerator::<DefaultRandomGenerator>::new(seeder.seed());
///
/// // Create the GlweSecretKey
/// let glwe_secret_key = allocate_and_generate_new_partial_binary_glwe_secret_key(

5
tfhe/src/core_crypto/experimental/algorithms/lwe_shrinking_keyswitch.rs
View File

@@ -30,9 +30,8 @@ use crate::core_crypto::experimental::entities::LweShrinkingKeyswitchKey;
/// let mut seeder = new_seeder();
/// let seeder = seeder.as_mut();
/// let mut encryption_generator =
/// EncryptionRandomGenerator::<ActivatedRandomGenerator>::new(seeder.seed(), seeder);
/// let mut secret_generator =
/// SecretRandomGenerator::<ActivatedRandomGenerator>::new(seeder.seed());
/// EncryptionRandomGenerator::<DefaultRandomGenerator>::new(seeder.seed(), seeder);
/// let mut secret_generator = SecretRandomGenerator::<DefaultRandomGenerator>::new(seeder.seed());
///
/// // Create the large LweSecretKey
/// let large_lwe_secret_key =

3
tfhe/src/core_crypto/experimental/algorithms/partial_glwe_secret_key_generation.rs
View File

@@ -51,8 +51,7 @@ pub fn generate_partial_binary_glwe_secret_key<Scalar, KeyCont, Gen>(
/// // Create the PRNG
/// let mut seeder = new_seeder();
/// let seeder = seeder.as_mut();
/// let mut secret_generator =
/// SecretRandomGenerator::<ActivatedRandomGenerator>::new(seeder.seed());
/// let mut secret_generator = SecretRandomGenerator::<DefaultRandomGenerator>::new(seeder.seed());
///
/// let mut glwe_secret_key: GlweSecretKeyOwned<u64> =
/// allocate_and_generate_new_partial_binary_glwe_secret_key(

2
tfhe/src/core_crypto/prelude.rs
View File

@@ -10,7 +10,7 @@ pub use super::commons::computation_buffers::ComputationBuffers;
pub use super::commons::dispersion::*;
pub use super::commons::generators::{EncryptionRandomGenerator, SecretRandomGenerator};
pub use super::commons::math::decomposition::SignedDecomposer;
pub use super::commons::math::random::{ActivatedRandomGenerator, Gaussian, TUniform};
pub use super::commons::math::random::{DefaultRandomGenerator, Gaussian, TUniform};
pub use super::commons::parameters::*;
pub use super::commons::traits::*;
pub use super::entities::*;

4
tfhe/src/high_level_api/keys/inner.rs
View File

@@ -1,6 +1,6 @@
use crate::conformance::ParameterSetConformant;
use crate::core_crypto::commons::generators::DeterministicSeeder;
use crate::core_crypto::prelude::{ActivatedRandomGenerator, KeyswitchKeyConformanceParams};
use crate::core_crypto::prelude::{DefaultRandomGenerator, KeyswitchKeyConformanceParams};
use crate::high_level_api::backward_compatibility::keys::*;
use crate::integer::compression_keys::{
CompressedCompressionKey, CompressedDecompressionKey, CompressionKey, CompressionPrivateKeys,
@@ -99,7 +99,7 @@ impl IntegerClientKey {
(config.block_parameters.message_modulus().0) == 2 || config.block_parameters.message_modulus().0 == 4,
"This API only supports parameters for which the MessageModulus is 2 or 4 (1 or 2 bits per block)",
);
let mut seeder = DeterministicSeeder::<ActivatedRandomGenerator>::new(seed);
let mut seeder = DeterministicSeeder::<DefaultRandomGenerator>::new(seed);
let cks = crate::shortint::engine::ShortintEngine::new_from_seeder(&mut seeder)
.new_client_key(config.block_parameters.into());

10
tfhe/src/integer/oprf.rs
View File

@@ -1,6 +1,6 @@
use super::{RadixCiphertext, ServerKey, SignedRadixCiphertext};
use crate::core_crypto::commons::generators::DeterministicSeeder;
use crate::core_crypto::prelude::ActivatedRandomGenerator;
use crate::core_crypto::prelude::DefaultRandomGenerator;
use rayon::iter::{IndexedParallelIterator, IntoParallelIterator, ParallelIterator};
pub use tfhe_csprng::seeders::{Seed, Seeder};
@@ -41,7 +41,7 @@ impl ServerKey {
assert!(self.message_modulus().0.is_power_of_two());
let message_bits_count = self.message_modulus().0.ilog2() as u64;
let mut deterministic_seeder = DeterministicSeeder::<ActivatedRandomGenerator>::new(seed);
let mut deterministic_seeder = DeterministicSeeder::<DefaultRandomGenerator>::new(seed);
let seeds: Vec<Seed> = (0..num_blocks)
.map(|_| deterministic_seeder.seed())
@@ -120,7 +120,7 @@ impl ServerKey {
assert!(self.message_modulus().0.is_power_of_two());
let message_bits_count = self.message_modulus().0.ilog2() as u64;
let mut deterministic_seeder = DeterministicSeeder::<ActivatedRandomGenerator>::new(seed);
let mut deterministic_seeder = DeterministicSeeder::<DefaultRandomGenerator>::new(seed);
let seeds: Vec<Seed> = (0..num_blocks)
.map(|_| deterministic_seeder.seed())
@@ -187,7 +187,7 @@ impl ServerKey {
assert!(self.message_modulus().0.is_power_of_two());
let message_bits_count = self.message_modulus().0.ilog2() as u64;
let mut deterministic_seeder = DeterministicSeeder::<ActivatedRandomGenerator>::new(seed);
let mut deterministic_seeder = DeterministicSeeder::<DefaultRandomGenerator>::new(seed);
let seeds: Vec<Seed> = (0..num_blocks)
.map(|_| deterministic_seeder.seed())
@@ -253,7 +253,7 @@ impl ServerKey {
assert!(self.message_modulus().0.is_power_of_two());
let message_bits_count = self.message_modulus().0.ilog2() as u64;
let mut deterministic_seeder = DeterministicSeeder::<ActivatedRandomGenerator>::new(seed);
let mut deterministic_seeder = DeterministicSeeder::<DefaultRandomGenerator>::new(seed);
let seeds: Vec<Seed> = (0..num_blocks)
.map(|_| deterministic_seeder.seed())

4
tfhe/src/js_on_wasm_api/boolean.rs
View File

@@ -1,6 +1,6 @@
use crate::core_crypto::commons::generators::DeterministicSeeder;
use crate::core_crypto::commons::math::random::Seed;
use crate::core_crypto::prelude::ActivatedRandomGenerator;
use crate::core_crypto::prelude::DefaultRandomGenerator;
use std::panic::set_hook;
use wasm_bindgen::prelude::*;
@@ -152,7 +152,7 @@ impl Boolean {
let seed_low_bytes: u128 = seed_low_bytes.into();
let seed: u128 = (seed_high_bytes << 64) | seed_low_bytes;
let mut seeder = DeterministicSeeder::<ActivatedRandomGenerator>::new(Seed(seed));
let mut seeder = DeterministicSeeder::<DefaultRandomGenerator>::new(Seed(seed));
let key = crate::boolean::engine::BooleanEngine::new_from_seeder(&mut seeder)
.create_client_key(parameters.0);
BooleanClientKey(key)

4
tfhe/src/js_on_wasm_api/shortint.rs
View File

@@ -1,7 +1,7 @@
#![allow(clippy::use_self)]
use crate::core_crypto::commons::generators::DeterministicSeeder;
use crate::core_crypto::commons::math::random::Seed;
use crate::core_crypto::prelude::ActivatedRandomGenerator;
use crate::core_crypto::prelude::DefaultRandomGenerator;
use crate::js_on_wasm_api::js_high_level_api::into_js_error;
use crate::shortint::parameters::classic::compact_pk::*;
use crate::shortint::parameters::compact_public_key_only::p_fail_2_minus_64::ks_pbs::V0_11_PARAM_PKE_MESSAGE_2_CARRY_2_KS_PBS_TUNIFORM_2M64;
@@ -457,7 +457,7 @@ impl Shortint {
let seed_low_bytes: u128 = seed_low_bytes.into();
let seed: u128 = (seed_high_bytes << 64) | seed_low_bytes;
let mut seeder = DeterministicSeeder::<ActivatedRandomGenerator>::new(Seed(seed));
let mut seeder = DeterministicSeeder::<DefaultRandomGenerator>::new(Seed(seed));
ShortintClientKey(
crate::shortint::engine::ShortintEngine::new_from_seeder(&mut seeder)
.new_client_key(parameters.0.into()),

12
tfhe/src/shortint/engine/mod.rs
View File

@@ -11,7 +11,7 @@ use crate::core_crypto::commons::generators::{
};
#[cfg(feature = "zk-pok")]
use crate::core_crypto::commons::math::random::RandomGenerator;
use crate::core_crypto::commons::math::random::{ActivatedRandomGenerator, Seeder};
use crate::core_crypto::commons::math::random::{DefaultRandomGenerator, Seeder};
use crate::core_crypto::entities::*;
use crate::core_crypto::prelude::{ContainerMut, GlweSize};
use crate::core_crypto::seeders::new_seeder;
@@ -299,19 +299,19 @@ impl std::fmt::Display for EngineError {
/// This structs actually implements the logics into its methods.
pub struct ShortintEngine {
/// A structure containing a single CSPRNG to generate secret key coefficients.
pub(crate) secret_generator: SecretRandomGenerator<ActivatedRandomGenerator>,
pub(crate) secret_generator: SecretRandomGenerator<DefaultRandomGenerator>,
/// A structure containing two CSPRNGs to generate material for encryption like public masks
/// and secret errors.
///
/// The [`EncryptionRandomGenerator`] contains two CSPRNGs, one publicly seeded used to
/// generate mask coefficients and one privately seeded used to generate errors during
/// encryption.
pub(crate) encryption_generator: EncryptionRandomGenerator<ActivatedRandomGenerator>,
pub(crate) encryption_generator: EncryptionRandomGenerator<DefaultRandomGenerator>,
/// A seeder that can be called to generate 128 bits seeds, useful to create new
/// [`EncryptionRandomGenerator`] to encrypt seeded types.
pub(crate) seeder: DeterministicSeeder<ActivatedRandomGenerator>,
pub(crate) seeder: DeterministicSeeder<DefaultRandomGenerator>,
#[cfg(feature = "zk-pok")]
pub(crate) random_generator: RandomGenerator<ActivatedRandomGenerator>,
pub(crate) random_generator: RandomGenerator<DefaultRandomGenerator>,
pub(crate) computation_buffers: ComputationBuffers,
ciphertext_buffers: Memory,
}
@@ -345,7 +345,7 @@ impl ShortintEngine {
pub fn new_from_seeder(root_seeder: &mut dyn Seeder) -> Self {
let mut deterministic_seeder =
DeterministicSeeder::<ActivatedRandomGenerator>::new(root_seeder.seed());
DeterministicSeeder::<DefaultRandomGenerator>::new(root_seeder.seed());
// Note that the operands are evaluated from left to right for Rust Struct expressions
// See: https://doc.rust-lang.org/stable/reference/expressions.html?highlight=left#evaluation-order-of-operands

5
tfhe/src/shortint/oprf.rs
View File

@@ -162,7 +162,7 @@ impl ServerKey {
pub(crate) mod test {
use crate::core_crypto::commons::generators::DeterministicSeeder;
use crate::core_crypto::prelude::{
decrypt_lwe_ciphertext, ActivatedRandomGenerator, GlweSecretKey, LweSecretKey,
decrypt_lwe_ciphertext, DefaultRandomGenerator, GlweSecretKey, LweSecretKey,
};
use crate::shortint::engine::ShortintEngine;
use crate::shortint::{ClientKey, ServerKey};
@@ -199,8 +199,7 @@ pub(crate) mod test {
parameters: parameters.into(),
};
let mut deterministic_seeder =
DeterministicSeeder::<ActivatedRandomGenerator>::new(Seed(0));
let mut deterministic_seeder = DeterministicSeeder::<DefaultRandomGenerator>::new(Seed(0));
let mut engine = ShortintEngine::new_from_seeder(&mut deterministic_seeder);