1 files changed, 64 insertions, 79 deletions

diff --git a/test/ec/test_mult.py b/test/ec/test_mult.py
index 3abc72c..ffdbf7f 100644
--- a/test/ec/test_mult.py
+++ b/test/ec/test_mult.py
@@ -28,94 +28,73 @@ class ScalarMultiplierTests(TestCase):
         else:
             assert one.equals(other)
 
+    def do_basic_test(self, mult_class, group, base, add, dbl, scale, neg=None):
+        mult = mult_class(*self.get_formulas(group.curve.coordinate_model, add, dbl, neg, scale))
+        mult.init(group, base)
+        res = mult.multiply(314)
+        other = mult.multiply(157)
+        mult.init(group, other)
+        other = mult.multiply(2)
+        self.assertPointEquality(res, other, scale)
+        mult.init(group, base)
+        self.assertEqual(InfinityPoint(group.curve.coordinate_model), mult.multiply(0))
+
     @parameterized.expand([
         ("scaled", "add-1998-cmo", "dbl-1998-cmo", "z"),
         ("none", "add-1998-cmo", "dbl-1998-cmo", None)
     ])
     def test_rtl(self, name, add, dbl, scale):
-        mult = RTLMultiplier(self.secp128r1, *self.get_formulas(self.coords, add, dbl, scale))
-        res = mult.multiply(10, self.base)
-        other = mult.multiply(5, self.base)
-        other = mult.multiply(2, other)
-        self.assertPointEquality(res, other, scale)
-        self.assertEqual(InfinityPoint(self.coords), mult.multiply(0, self.base))
+        self.do_basic_test(RTLMultiplier, self.secp128r1, self.base, add, dbl, scale)
 
     @parameterized.expand([
         ("scaled", "add-1998-cmo", "dbl-1998-cmo", "z"),
         ("none", "add-1998-cmo", "dbl-1998-cmo", None)
     ])
     def test_ltr(self, name, add, dbl, scale):
-        mult = LTRMultiplier(self.secp128r1, *self.get_formulas(self.coords, add, dbl, scale))
-        res = mult.multiply(10, self.base)
-        other = mult.multiply(5, self.base)
-        other = mult.multiply(2, other)
-        self.assertPointEquality(res, other, scale)
-        self.assertEqual(InfinityPoint(self.coords), mult.multiply(0, self.base))
+        self.do_basic_test(LTRMultiplier, self.secp128r1, self.base, add, dbl, scale)
 
     @parameterized.expand([
         ("scaled", "add-1998-cmo", "dbl-1998-cmo", "z"),
         ("none", "add-1998-cmo", "dbl-1998-cmo", None)
     ])
     def test_coron(self, name, add, dbl, scale):
-        mult = CoronMultiplier(self.secp128r1, *self.get_formulas(self.coords, add, dbl, scale))
-        res = mult.multiply(10, self.base)
-        other = mult.multiply(5, self.base)
-        other = mult.multiply(2, other)
-        self.assertPointEquality(res, other, scale)
-        self.assertEqual(InfinityPoint(self.coords), mult.multiply(0, self.base))
+        self.do_basic_test(CoronMultiplier, self.secp128r1, self.base, add, dbl, scale)
 
     def test_ladder(self):
-        mult = LadderMultiplier(self.curve25519, self.coords25519.formulas["ladd-1987-m"],
-                                self.coords25519.formulas["dbl-1987-m"],
-                                self.coords25519.formulas["scale"])
-        res = mult.multiply(15, self.base25519)
-        other = mult.multiply(5, self.base25519)
-        other = mult.multiply(3, other)
-        self.assertEqual(res, other)
-        self.assertEqual(InfinityPoint(self.coords25519), mult.multiply(0, self.base25519))
+        self.do_basic_test(LadderMultiplier, self.curve25519, self.base25519, "ladd-1987-m",
+                           "dbl-1987-m", "scale")
 
     @parameterized.expand([
         ("scaled", "add-1998-cmo", "dbl-1998-cmo", "z"),
         ("none", "add-1998-cmo", "dbl-1998-cmo", None)
     ])
     def test_simple_ladder(self, name, add, dbl, scale):
-        mult = SimpleLadderMultiplier(self.secp128r1,
-                                      *self.get_formulas(self.coords, add, dbl, scale))
-        res = mult.multiply(10, self.base)
-        other = mult.multiply(5, self.base)
-        other = mult.multiply(2, other)
-        self.assertPointEquality(res, other, scale)
-        self.assertEqual(InfinityPoint(self.coords), mult.multiply(0, self.base))
+        self.do_basic_test(SimpleLadderMultiplier, self.secp128r1, self.base, add, dbl, scale)
 
     @parameterized.expand([
         ("10", 15),
         ("2355498743", 2355498743,)
     ])
     def test_ladder_differential(self, name, num):
-        ladder = LadderMultiplier(self.curve25519, self.coords25519.formulas["ladd-1987-m"],
+        ladder = LadderMultiplier(self.coords25519.formulas["ladd-1987-m"],
                                   self.coords25519.formulas["dbl-1987-m"],
                                   self.coords25519.formulas["scale"])
-        differential = SimpleLadderMultiplier(self.curve25519,
-                                              self.coords25519.formulas["dadd-1987-m"],
+        differential = SimpleLadderMultiplier(self.coords25519.formulas["dadd-1987-m"],
                                               self.coords25519.formulas["dbl-1987-m"],
                                               self.coords25519.formulas["scale"])
-        res_ladder = ladder.multiply(num, self.base25519)
-        res_differential = differential.multiply(num, self.base25519)
+        ladder.init(self.curve25519, self.base25519)
+        res_ladder = ladder.multiply(num)
+        differential.init(self.curve25519, self.base25519)
+        res_differential = differential.multiply(num)
         self.assertEqual(res_ladder, res_differential)
-        self.assertEqual(InfinityPoint(self.coords25519), differential.multiply(0, self.base25519))
+        self.assertEqual(InfinityPoint(self.coords25519), differential.multiply(0))
 
     @parameterized.expand([
         ("scaled", "add-1998-cmo", "dbl-1998-cmo", "neg", "z"),
         ("none", "add-1998-cmo", "dbl-1998-cmo", "neg", None)
     ])
     def test_binary_naf(self, name, add, dbl, neg, scale):
-        mult = BinaryNAFMultiplier(self.secp128r1,
-                                   *self.get_formulas(self.coords, add, dbl, neg, scale))
-        res = mult.multiply(10, self.base)
-        other = mult.multiply(5, self.base)
-        other = mult.multiply(2, other)
-        self.assertPointEquality(res, other, scale)
-        self.assertEqual(InfinityPoint(self.coords), mult.multiply(0, self.base))
+        self.do_basic_test(BinaryNAFMultiplier, self.secp128r1, self.base, add, dbl, scale, neg)
 
     @parameterized.expand([
         ("scaled3", "add-1998-cmo", "dbl-1998-cmo", "neg", 3, "z"),
@@ -123,16 +102,20 @@ class ScalarMultiplierTests(TestCase):
     ])
     def test_window_naf(self, name, add, dbl, neg, width, scale):
         formulas = self.get_formulas(self.coords, add, dbl, neg, scale)
-        mult = WindowNAFMultiplier(self.secp128r1, *formulas[:3], width, *formulas[3:])
-        res = mult.multiply(10, self.base)
-        other = mult.multiply(5, self.base)
-        other = mult.multiply(2, other)
+        mult = WindowNAFMultiplier(*formulas[:3], width, *formulas[3:])
+        mult.init(self.secp128r1, self.base)
+        res = mult.multiply(10)
+        other = mult.multiply(5)
+        mult.init(self.secp128r1, other)
+        other = mult.multiply(2)
         self.assertPointEquality(res, other, scale)
-        self.assertEqual(InfinityPoint(self.coords), mult.multiply(0, self.base))
+        mult.init(self.secp128r1, self.base)
+        self.assertEqual(InfinityPoint(self.coords), mult.multiply(0))
 
-        mult = WindowNAFMultiplier(self.secp128r1, *formulas[:3], width, *formulas[3:],
+        mult = WindowNAFMultiplier(*formulas[:3], width, *formulas[3:],
                                    precompute_negation=True)
-        res_precompute = mult.multiply(10, self.base)
+        mult.init(self.secp128r1, self.base)
+        res_precompute = mult.multiply(10)
         self.assertPointEquality(res_precompute, res, scale)
 
     @parameterized.expand([
@@ -140,58 +123,60 @@ class ScalarMultiplierTests(TestCase):
         ("2355498743", 2355498743,)
     ])
     def test_basic_multipliers(self, name, num):
-        ltr = LTRMultiplier(self.secp128r1, self.coords.formulas["add-1998-cmo"],
+        ltr = LTRMultiplier(self.coords.formulas["add-1998-cmo"],
                             self.coords.formulas["dbl-1998-cmo"], self.coords.formulas["z"])
-        res_ltr = ltr.multiply(num, self.base)
-        rtl = RTLMultiplier(self.secp128r1, self.coords.formulas["add-1998-cmo"],
+        ltr.init(self.secp128r1, self.base)
+        res_ltr = ltr.multiply(num)
+        rtl = RTLMultiplier(self.coords.formulas["add-1998-cmo"],
                             self.coords.formulas["dbl-1998-cmo"], self.coords.formulas["z"])
-        res_rtl = rtl.multiply(num, self.base)
+        rtl.init(self.secp128r1, self.base)
+        res_rtl = rtl.multiply(num)
         self.assertEqual(res_ltr, res_rtl)
 
-        ltr_always = LTRMultiplier(self.secp128r1, self.coords.formulas["add-1998-cmo"],
+        ltr_always = LTRMultiplier(self.coords.formulas["add-1998-cmo"],
                                    self.coords.formulas["dbl-1998-cmo"], self.coords.formulas["z"],
                                    always=True)
-        rtl_always = RTLMultiplier(self.secp128r1, self.coords.formulas["add-1998-cmo"],
+        rtl_always = RTLMultiplier(self.coords.formulas["add-1998-cmo"],
                                    self.coords.formulas["dbl-1998-cmo"], self.coords.formulas["z"],
                                    always=True)
-        res_ltr_always = ltr_always.multiply(num, self.base)
-        res_rtl_always = rtl_always.multiply(num, self.base)
+        ltr_always.init(self.secp128r1, self.base)
+        rtl_always.init(self.secp128r1, self.base)
+        res_ltr_always = ltr_always.multiply(num)
+        res_rtl_always = rtl_always.multiply(num)
         self.assertEqual(res_ltr, res_ltr_always)
         self.assertEqual(res_rtl, res_rtl_always)
 
-        bnaf = BinaryNAFMultiplier(self.secp128r1, self.coords.formulas["add-1998-cmo"],
+        bnaf = BinaryNAFMultiplier(self.coords.formulas["add-1998-cmo"],
                                    self.coords.formulas["dbl-1998-cmo"],
                                    self.coords.formulas["neg"], self.coords.formulas["z"])
-        res_bnaf = bnaf.multiply(num, self.base)
+        bnaf.init(self.secp128r1, self.base)
+        res_bnaf = bnaf.multiply(num)
         self.assertEqual(res_bnaf, res_ltr)
 
-        wnaf = WindowNAFMultiplier(self.secp128r1, self.coords.formulas["add-1998-cmo"],
+        wnaf = WindowNAFMultiplier(self.coords.formulas["add-1998-cmo"],
                                    self.coords.formulas["dbl-1998-cmo"],
                                    self.coords.formulas["neg"], 3, self.coords.formulas["z"])
-        res_wnaf = wnaf.multiply(num, self.base)
+        wnaf.init(self.secp128r1, self.base)
+        res_wnaf = wnaf.multiply(num)
         self.assertEqual(res_wnaf, res_ltr)
 
-        ladder = SimpleLadderMultiplier(self.secp128r1, self.coords.formulas["add-1998-cmo"],
+        ladder = SimpleLadderMultiplier(self.coords.formulas["add-1998-cmo"],
                                         self.coords.formulas["dbl-1998-cmo"],
                                         self.coords.formulas["z"])
-        res_ladder = ladder.multiply(num, self.base)
+        ladder.init(self.secp128r1, self.base)
+        res_ladder = ladder.multiply(num)
         self.assertEqual(res_ladder, res_ltr)
 
-        coron = CoronMultiplier(self.secp128r1, self.coords.formulas["add-1998-cmo"],
+        coron = CoronMultiplier(self.coords.formulas["add-1998-cmo"],
                                 self.coords.formulas["dbl-1998-cmo"],
                                 self.coords.formulas["z"])
-        res_coron = coron.multiply(num, self.base)
+        coron.init(self.secp128r1, self.base)
+        res_coron = coron.multiply(num)
         self.assertEqual(res_coron, res_ltr)
 
     def test_init_fail(self):
+        mult = SimpleLadderMultiplier(self.coords25519.formulas["dadd-1987-m"],
+                                      self.coords25519.formulas["dbl-1987-m"],
+                                      self.coords25519.formulas["scale"])
         with self.assertRaises(ValueError):
-            SimpleLadderMultiplier(self.secp128r1,
-                                   self.coords25519.formulas["dadd-1987-m"],
-                                   self.coords25519.formulas["dbl-1987-m"],
-                                   self.coords25519.formulas["scale"])
-
-    def test_mult_fail(self):
-        mult = LTRMultiplier(self.secp128r1, self.coords.formulas["add-1998-cmo"],
-                             self.coords.formulas["dbl-1998-cmo"], self.coords.formulas["z"])
-        with self.assertRaises(ValueError):
-            mult.multiply(15)
+            mult.init(self.secp128r1, self.base)