A plus bc mod q redo (#274)

* Update how a_plus_bc_mod_q is calling the big number package. Use 256 bit routines rather than 4096 routines.

* Add benchmark test for a_plus_bc_mod_q

* Use the abstraction layer.

* Should have been using the constant.

Co-authored-by: Jeff <[email protected]>

Author: jeffspel-crypto

src/electionguard/group.cpp

@@ -755,38 +755,31 @@ namespace electionguard
     unique_ptr<ElementModQ> a_plus_bc_mod_q(const ElementModQ &a, const ElementModQ &b,
                                             const ElementModQ &c)
     {
-        // since the result of b*c can be larger than Q's 256,
-        // use P's length and 4096 Hacl for rest of calculation
-
-        uint64_t resultBC[MAX_P_LEN] = {}; // init to MAX_P_LEN
+        // multiply b * c and the result will be twice Q in size
+        uint64_t bc[MAX_Q_LEN_DOUBLE] = {};
         Bignum256::mul(const_cast<ElementModQ &>(b).get(), const_cast<ElementModQ &>(c).get(),
-                       static_cast<uint64_t *>(resultBC));
-
-        auto bc_as_p = make_unique<ElementModP>(resultBC, true);
-        auto a_as_p = a.toElementModP();
-
-        uint64_t a_plus_bc_result[MAX_P_LEN_DOUBLE] = {};
-        uint64_t carry =
-          Bignum4096::add(a_as_p->get(), bc_as_p->get(), static_cast<uint64_t *>(a_plus_bc_result));
+                       bc);
 
-        // we should never overflow P space since our max size
-        // is resultBC[MAX_Q_LEN_DOUBLE] + a[MAX_Q_LEN]
-        if (carry > 0) {
-            throw overflow_error("a_plus_bc_mod_q add operation out of bounds");
+        // perform the mod operation on bc
+        uint64_t bc_mod_q[MAX_Q_LEN] = {};
+        const auto &q = Q();
+        bool modSuccess = Bignum256::mod(q.get(), bc, bc_mod_q);
+        if (!modSuccess) {
+            throw runtime_error("a_plus_bc_mod_q mod operation failed");
         }
 
-        const auto &q = Q();
-        auto q_as_p = q.toElementModP();
-        uint64_t resModQ[MAX_P_LEN] = {};
-        bool modSuccess = Bignum4096::mod(q_as_p->get(), static_cast<uint64_t *>(a_plus_bc_result),
-                                          static_cast<uint64_t *>(resModQ));
+        uint64_t a_plus_bc[MAX_Q_LEN_DOUBLE] = {};
+        uint64_t carry = Bignum256::add(const_cast<ElementModQ &>(a).get(), bc_mod_q, a_plus_bc);
+        // put the carry in
+        a_plus_bc[MAX_Q_LEN] = carry;
+
+        uint64_t res[MAX_Q_LEN] = {};
+        modSuccess = Bignum256::mod(q.get(), a_plus_bc, res);
         if (!modSuccess) {
             throw runtime_error("a_plus_bc_mod_q mod operation failed");
         }
-        uint64_t result[MAX_Q_LEN] = {};
-        memcpy(static_cast<uint64_t *>(result), resModQ, MAX_Q_SIZE);
 
-        return make_unique<ElementModQ>(result, true);
+        return make_unique<ElementModQ>(res, true);
     }
 
     unique_ptr<ElementModQ> sub_from_q(const ElementModQ &a)

test/electionguard/benchmark/bench_group.cpp

@@ -33,6 +33,11 @@ class GroupElementFixture : public benchmark::Fixture
 
         auto array_size = sizeof(LARGE_P_ARRAY_1) / sizeof(uint64_t);
         p1_vector.assign(&LARGE_P_ARRAY_1[0], &LARGE_P_ARRAY_1[array_size]);
+
+        a = rand_q();
+        b = rand_q();
+        c = rand_q();
+
     }
 
     void TearDown(const ::benchmark::State &state) {}
@@ -43,6 +48,9 @@ class GroupElementFixture : public benchmark::Fixture
     unique_ptr<ElementModQ> q1;
     unique_ptr<ElementModQ> q2;
     vector<uint64_t> p1_vector;
+    unique_ptr<ElementModQ> a;
+    unique_ptr<ElementModQ> b;
+    unique_ptr<ElementModQ> c;
 };
 
 BENCHMARK_DEFINE_F(GroupElementFixture, ElementModP_fromArray)(benchmark::State &state)
@@ -216,3 +224,12 @@ BENCHMARK_DEFINE_F(GroupElementFixture, add_mod_q_overflow)(benchmark::State &st
 }
 
 BENCHMARK_REGISTER_F(GroupElementFixture, add_mod_q_overflow)->Unit(benchmark::kMillisecond);
+
+BENCHMARK_DEFINE_F(GroupElementFixture, a_plus_bc_mod_q)(benchmark::State &state)
+{
+    for (auto _ : state) {
+        auto r = a_plus_bc_mod_q(*a, *b, *c);
+    }
+}
+
+BENCHMARK_REGISTER_F(GroupElementFixture, a_plus_bc_mod_q)->Unit(benchmark::kMillisecond);