Botan::EC_Point_Var_Point_Precompute Class Reference

#include <point_mul.h>

Public Member Functions
	EC_Point_Var_Point_Precompute (const EC_Point &point, RandomNumberGenerator &rng, std::vector< BigInt > &ws)
EC_Point	mul (const BigInt &k, RandomNumberGenerator &rng, const BigInt &group_order, std::vector< BigInt > &ws) const

Detailed Description

Definition at line 40 of file point_mul.h.

Constructor & Destructor Documentation

EC_Point_Var_Point_Precompute()

Botan::EC_Point_Var_Point_Precompute::EC_Point_Var_Point_Precompute	(	const EC_Point &	point,
		RandomNumberGenerator &	rng,
		std::vector< BigInt > &	ws )

Definition at line 173 of file point_mul.cpp.

                                                                                    :
      m_curve(ipoint.get_curve()), m_p_words(m_curve.get_p_words()) {
   if(ws.size() < EC_Point::WORKSPACE_SIZE) {
      ws.resize(EC_Point::WORKSPACE_SIZE);
   }
 
   auto point = ipoint;
   point.randomize_repr(rng);
 
   std::vector<EC_Point> U(static_cast<size_t>(1) << WindowBits);
   U[0] = point.zero();
   U[1] = point;
 
   for(size_t i = 2; i < U.size(); i += 2) {
      U[i] = U[i / 2].double_of(ws);
      U[i + 1] = U[i].plus(point, ws);
   }
 
   // Hack to handle Blinded_Point_Multiply
   if(rng.is_seeded()) {
      // Skipping zero point since it can't be randomized
      for(size_t i = 1; i != U.size(); ++i) {
         U[i].randomize_repr(rng);
      }
   }
 
   m_T.resize(U.size() * 3 * m_p_words);
 
   word* p = m_T.data();
   for(const auto& pt : U) {
      pt.get_x().encode_words(p, m_p_words);
      pt.get_y().encode_words(p + m_p_words, m_p_words);
      pt.get_z().encode_words(p + 2 * m_p_words, m_p_words);
      p += 3 * m_p_words;
   }
}

References Botan::RandomNumberGenerator::is_seeded(), Botan::EC_Point::randomize_repr(), and Botan::EC_Point::WORKSPACE_SIZE.

Member Function Documentation

mul()

EC_Point Botan::EC_Point_Var_Point_Precompute::mul	(	const BigInt &	k,
		RandomNumberGenerator &	rng,
		const BigInt &	group_order,
		std::vector< BigInt > &	ws ) const

Definition at line 212 of file point_mul.cpp.

                                                                         {
   if(k.is_negative()) {
      throw Invalid_Argument("EC_Point_Var_Point_Precompute scalar must be positive");
   }
   if(ws.size() < EC_Point::WORKSPACE_SIZE) {
      ws.resize(EC_Point::WORKSPACE_SIZE);
   }
 
   // Choose a small mask m and use k' = k + m*order (Coron's 1st countermeasure)
   const BigInt scalar = k + group_order * blinding_mask(group_order, rng);
 
   const size_t elem_size = 3 * m_p_words;
   const size_t window_elems = static_cast<size_t>(1) << WindowBits;
 
   size_t windows = round_up(scalar.bits(), WindowBits) / WindowBits;
   EC_Point R(m_curve);
   secure_vector<word> e(elem_size);
 
   if(windows > 0) {
      windows--;
 
      const uint32_t w = scalar.get_substring(windows * WindowBits, WindowBits);
 
      clear_mem(e.data(), e.size());
      for(size_t i = 1; i != window_elems; ++i) {
         const auto wmask = CT::Mask<word>::is_equal(w, i);
 
         for(size_t j = 0; j != elem_size; ++j) {
            e[j] |= wmask.if_set_return(m_T[i * elem_size + j]);
         }
      }
 
      R.add(e.data(), m_p_words, &e[m_p_words], m_p_words, &e[2 * m_p_words], m_p_words, ws);
 
      /*
      Randomize after adding the first nibble as before the addition R
      is zero, and we cannot effectively randomize the point
      representation of the zero point.
      */
      R.randomize_repr(rng, ws[0].get_word_vector());
   }
 
   while(windows > 0) {
      R.mult2i(WindowBits, ws);
 
      const uint32_t w = scalar.get_substring((windows - 1) * WindowBits, WindowBits);
 
      clear_mem(e.data(), e.size());
      for(size_t i = 1; i != window_elems; ++i) {
         const auto wmask = CT::Mask<word>::is_equal(w, i);
 
         for(size_t j = 0; j != elem_size; ++j) {
            e[j] |= wmask.if_set_return(m_T[i * elem_size + j]);
         }
      }
 
      R.add(e.data(), m_p_words, &e[m_p_words], m_p_words, &e[2 * m_p_words], m_p_words, ws);
 
      windows--;
   }
 
   BOTAN_ASSERT_NOMSG(R.on_the_curve());
 
   return R;
}

References Botan::EC_Point::add(), Botan::BigInt::bits(), BOTAN_ASSERT_NOMSG, Botan::clear_mem(), Botan::BigInt::get_substring(), Botan::CT::Mask< T >::is_equal(), Botan::BigInt::is_negative(), mul(), Botan::EC_Point::mult2i(), Botan::EC_Point::on_the_curve(), Botan::EC_Point::randomize_repr(), Botan::round_up(), and Botan::EC_Point::WORKSPACE_SIZE.

Referenced by mul(), and Botan::EC_Group_Data::mul_px_qy().

---

The documentation for this class was generated from the following files:

• src/lib/pubkey/ec_group/legacy_ec_point/point_mul.h
• src/lib/pubkey/ec_group/legacy_ec_point/point_mul.cpp