Change prng for sharing

Author: nicolaimueller

inc/Hardware/Definitions.hpp

@@ -59,6 +59,7 @@ class Simulation {
     uint64_t clock_signal_index_;
     uint64_t number_of_clock_cycles_;
     uint64_t number_of_enablers_;
+    uint64_t number_of_probe_extensions_;
     uint64_t number_of_processed_simulations;
     std::vector<std::vector<uint64_t>> always_random_inputs_indices_;
     std::vector<uint64_t> selected_groups_;

inc/Util/Sharing.hpp

@@ -135,6 +135,10 @@ class Sharing {
    */
   void ConvertFqToPolynomial(fq_t& polynomial_fq, Polynomial& polynomial);
 
+  boost::dynamic_bitset<> ConvertPolynomialToBitset(
+      const Polynomial& polynomial) const;
+
+
   void SampleRandomPolynomial(fq_t& random_polynomial_fq);
 
   /**
@@ -208,7 +212,8 @@ class Sharing {
 
   fmpz_t prime_fmpz_;
   fq_ctx_t ctx_fq_;
-  flint_rand_t random_state_;
   fmpz_mod_poly_t fmpz_poly_;
   fmpz_mod_ctx_t ctx_fmpz_mod_;
+  boost::uniform_int<uint64_t> dist_;
+  boost::variate_generator<boost::mt19937&, boost::uniform_int<uint64_t>> gen_;
 };

src/Util/Sharing.cpp

@@ -5,18 +5,12 @@ Sharing::Sharing(uint64_t prime_base, uint64_t extension_degree,
     : prime_base_(prime_base),
       extension_degree_(extension_degree),
       size_coefficients_bits_(std::ceil(std::log2l(prime_base))),
-      length_of_elements_in_bits_(size_coefficients_bits_ * extension_degree) {
+      length_of_elements_in_bits_(size_coefficients_bits_ * extension_degree),
+      dist_(0, std::numeric_limits<uint64_t>::max()),
+      gen_(rng, dist_) {
+
   fmpz_init(prime_fmpz_);
   fmpz_set_ui(prime_fmpz_, prime_base_);
-  flint_randinit(random_state_);
-
-  boost::uniform_int<uint64_t> dist_(0, std::numeric_limits<uint64_t>::max());
-  boost::variate_generator<boost::mt19937&, boost::uniform_int<uint64_t>> gen_(
-      rng, dist_);
-
-  mp_limb_t seed1 = gen_();
-  mp_limb_t seed2 = gen_();
-  flint_randseed(random_state_, seed1, seed2);
 
   if (!irreducible_polynomial.empty()) {
     fmpz_mod_ctx_init(ctx_fmpz_mod_, prime_fmpz_);
@@ -42,7 +36,6 @@ Sharing::Sharing(uint64_t prime_base, uint64_t extension_degree,
 Sharing::~Sharing() {
   fmpz_clear(prime_fmpz_);
   fq_ctx_clear(ctx_fq_);
-  flint_randclear(random_state_);
   fmpz_mod_poly_clear(fmpz_poly_, ctx_fmpz_mod_);
   fmpz_mod_ctx_clear(ctx_fmpz_mod_);
 }
@@ -200,40 +193,67 @@ void Sharing::ConvertFqToPolynomial(fq_t& polynomial_fq,
   fmpz_clear(fmpz_coef);
 }
 
+boost::dynamic_bitset<> Sharing::ConvertPolynomialToBitset(
+    const Polynomial& polynomial) const {
+  uint64_t number_of_bits = length_of_elements_in_bits_;
+  uint64_t bit_index, coefficient_index;
+  boost::dynamic_bitset<> bitset(number_of_bits);
+
+  for (coefficient_index = 0; coefficient_index < polynomial.size();
+       ++coefficient_index) {
+    for (bit_index = 0; bit_index < size_coefficients_bits_; ++bit_index) {
+      bitset[coefficient_index * size_coefficients_bits_ + bit_index] =
+          (polynomial[coefficient_index] >> bit_index) & 1;
+    }
+  }
+
+  return bitset;
+}
+
+
 void Sharing::SampleRandomPolynomial(fq_t& random_polynomial_fq) {
-  fmpz_mod_poly_randtest(fmpz_poly_, random_state_, extension_degree_,
-                         ctx_fmpz_mod_);
-  fq_set_fmpz_mod_poly(random_polynomial_fq, fmpz_poly_, ctx_fq_);
+  fmpz_mod_poly_t random_fmpz;
+  fmpz_mod_poly_init(random_fmpz, ctx_fmpz_mod_);
+
+  fmpz_t coefficient;
+  fmpz_init(coefficient);
+
+  for (uint64_t index = 0; index < extension_degree_; ++index) {
+    fmpz_set_ui(coefficient, gen_());
+    fmpz_mod_poly_set_coeff_fmpz(random_fmpz, index, coefficient,
+                                 ctx_fmpz_mod_);
+  }
+
+  fq_set_fmpz_mod_poly(random_polynomial_fq, random_fmpz, ctx_fq_);
+  fmpz_mod_poly_clear(random_fmpz, ctx_fmpz_mod_);
+  fmpz_clear(coefficient);
 }
 
 std::vector<uint64_t> Sharing::SampleRandomBitslicedPolynomial() {
-  uint64_t bit_index, coefficient_index, simulation_index, index;
-  std::vector<uint64_t> bitsliced_polynomial(length_of_elements_in_bits_, 0);
+  uint64_t index, bit_index, bit_width = length_of_elements_in_bits_;
+  std::vector<uint64_t> bitsliced_polynomial(bit_width);
+  boost::dynamic_bitset<> bitset;
+  Polynomial polynomial(extension_degree_);
 
-  uint64_t coefficient;
-  fmpz_t fmpz_coef;
-  fmpz_init(fmpz_coef);
+  for (index = 0; index < 64; ++index) {
+    fq_t polynomial_fq;
+    fq_init(polynomial_fq, ctx_fq_);
+    SampleRandomPolynomial(polynomial_fq);
+    ConvertFqToPolynomial(polynomial_fq, polynomial);
+    bitset = ConvertPolynomialToBitset(polynomial);
 
-  for (simulation_index = 0; simulation_index < 64; ++simulation_index) {
-    index = 0;
-    fmpz_mod_poly_randtest(fmpz_poly_, random_state_, extension_degree_, ctx_fmpz_mod_);
-    for (coefficient_index = 0; coefficient_index < extension_degree_;
-         ++coefficient_index) {
-      fmpz_mod_poly_get_coeff_fmpz(fmpz_coef, fmpz_poly_, index, ctx_fmpz_mod_);
-      coefficient = fmpz_get_ui(fmpz_coef);
-      for (bit_index = 0; bit_index < size_coefficients_bits_; ++bit_index) {
-        bitsliced_polynomial[index] <<= 1;
-        bitsliced_polynomial[index] |= coefficient & 1;
-        coefficient >>= 1;
-        ++index;
-      }
+    for (bit_index = 0; bit_index < bit_width; ++bit_index) {
+      bitsliced_polynomial[bit_index] <<= 1;
+      bitsliced_polynomial[bit_index] |= bitset[bit_index];
     }
+
+    fq_clear(polynomial_fq, ctx_fq_);
   }
 
-  fmpz_clear(fmpz_coef);
   return bitsliced_polynomial;
 }
 
+
 std::vector<Polynomial> Sharing::Encode(fq_t& polynomial_fq,
                                         uint64_t number_of_shares,
                                         bool is_additive_masking) {