2 files changed, 163 insertions, 42 deletions

diff --git a/test/ec/test_countermeasures.py b/test/ec/test_countermeasures.py
index 0559d26..8a572e8 100644
--- a/test/ec/test_countermeasures.py
+++ b/test/ec/test_countermeasures.py
@@ -1,3 +1,6 @@
+from itertools import product
+from copy import copy
+
 import pytest
 
 from pyecsca.ec.countermeasures import (
@@ -6,7 +9,7 @@ from pyecsca.ec.countermeasures import (
     MultiplicativeSplitting,
     EuclideanSplitting,
 )
-from pyecsca.ec.mult import LTRMultiplier
+from pyecsca.ec.mult import *
 
 
 @pytest.fixture(params=["add-1998-cmo-2", "add-2015-rcb"])
@@ -20,81 +23,199 @@ def dbl(secp128r1, request):
 
 
 @pytest.fixture()
-def mult(secp128r1, add, dbl):
-    return LTRMultiplier(add, dbl, complete=False)
+def mults(secp128r1, add, dbl):
+    neg = secp128r1.curve.coordinate_model.formulas["neg"]
+    scale = secp128r1.curve.coordinate_model.formulas["z"]
+
+    ltr_options = {
+        "always": (True, False),
+        "complete": (True, False),
+        "accumulation_order": tuple(AccumulationOrder),
+    }
+    ltrs = [
+        LTRMultiplier(add, dbl, scale, **dict(zip(ltr_options.keys(), combination)))
+        for combination in product(*ltr_options.values())
+    ]
+    rtl_options = ltr_options
+    rtls = [
+        RTLMultiplier(add, dbl, scale, **dict(zip(rtl_options.keys(), combination)))
+        for combination in product(*rtl_options.values())
+    ]
+    bnaf_options = {
+        "direction": tuple(ProcessingDirection),
+        "accumulation_order": tuple(AccumulationOrder),
+    }
+    bnafs = [
+        BinaryNAFMultiplier(
+            add, dbl, neg, scale, **dict(zip(bnaf_options.keys(), combination))
+        )
+        for combination in product(*bnaf_options.values())
+    ]
+    wnaf_options = {
+        "precompute_negation": (True, False),
+        "width": (3, 5),
+        "accumulation_order": tuple(AccumulationOrder),
+    }
+    wnafs = [
+        WindowNAFMultiplier(
+            add, dbl, neg, scl=scale, **dict(zip(wnaf_options.keys(), combination))
+        )
+        for combination in product(*wnaf_options.values())
+    ]
+    booth_options = {
+        "precompute_negation": (True, False),
+        "width": (3, 5),
+        "accumulation_order": tuple(AccumulationOrder),
+    }
+    booths = [
+        WindowBoothMultiplier(
+            add, dbl, neg, scl=scale, **dict(zip(booth_options.keys(), combination))
+        )
+        for combination in product(*booth_options.values())
+    ]
+    ladder_options = {"complete": (True, False)}
+    ladders = [
+        SimpleLadderMultiplier(
+            add, dbl, scale, **dict(zip(ladder_options.keys(), combination))
+        )
+        for combination in product(*ladder_options.values())
+    ]
+    fixed_options = {"m": (5, 8), "accumulation_order": tuple(AccumulationOrder)}
+    fixeds = [
+        FixedWindowLTRMultiplier(
+            add, dbl, scl=scale, **dict(zip(fixed_options.keys(), combination))
+        )
+        for combination in product(*fixed_options.values())
+    ]
+    sliding_options = {
+        "width": (3, 5),
+        "recoding_direction": tuple(ProcessingDirection),
+        "accumulation_order": tuple(AccumulationOrder),
+    }
+    slides = [
+        SlidingWindowMultiplier(
+            add, dbl, scl=scale, **dict(zip(sliding_options.keys(), combination))
+        )
+        for combination in product(*sliding_options.values())
+    ]
+    precomp_options = {
+        "always": (True, False),
+        "complete": (True, False),
+        "direction": tuple(ProcessingDirection),
+        "accumulation_order": tuple(AccumulationOrder),
+    }
+    precomps = [
+        FullPrecompMultiplier(
+            add, dbl, scl=scale, **dict(zip(precomp_options.keys(), combination))
+        )
+        for combination in product(*precomp_options.values())
+    ]
+    bgmw_options = {
+        "width": (2, 3, 5),
+        "direction": tuple(ProcessingDirection),
+        "accumulation_order": tuple(AccumulationOrder),
+    }
+    bgmws = [
+        BGMWMultiplier(
+            add, dbl, scl=scale, **dict(zip(bgmw_options.keys(), combination))
+        )
+        for combination in product(*bgmw_options.values())
+    ]
+    comb_options = {"width": (2, 3, 4, 5), "accumulation_order": tuple(AccumulationOrder)}
+    combs = [
+        CombMultiplier(
+            add, dbl, scl=scale, **dict(zip(comb_options.keys(), combination))
+        )
+        for combination in product(*comb_options.values())
+    ]
+
+    return (
+            ltrs
+            + rtls
+            + bnafs
+            + wnafs
+            + booths
+            + [CoronMultiplier(add, dbl, scale)]
+            + ladders
+            + fixeds
+            + slides
+            + precomps
+            + bgmws
+            + combs
+    )
 
 
 @pytest.mark.parametrize(
     "num",
     [
-        325385790209017329644351321912443757746,
-        123456789314159265358979323846264338327,
-        987654321314159265358979323846264338327,
-        786877845665557891354654531354008066400,
+        3253857902090173296443513219124437746,
+        1234567893141592653589793238464338327,
     ],
 )
-def test_group_scalar_rand(mult, secp128r1, num):
+def test_group_scalar_rand(mults, secp128r1, num):
+    mult = copy(mults[0])
     mult.init(secp128r1, secp128r1.generator)
     raw = mult.multiply(num)
 
-    gsr = GroupScalarRandomization(mult)
-    gsr.init(secp128r1, secp128r1.generator)
-    masked = gsr.multiply(num)
-    assert raw.equals(masked)
+    for mult in mults:
+        gsr = GroupScalarRandomization(mult)
+        gsr.init(secp128r1, secp128r1.generator)
+        masked = gsr.multiply(num)
+        assert raw.equals(masked)
 
 
 @pytest.mark.parametrize(
     "num",
     [
-        325385790209017329644351321912443757746,
-        123456789314159265358979323846264338327,
-        987654321314159265358979323846264338327,
-        786877845665557891354654531354008066400,
+        3253857902090173296443513219124437746,
+        1234567893141592653589793238464338327,
     ],
 )
-def test_additive_splitting(mult, secp128r1, num):
+def test_additive_splitting(mults, secp128r1, num):
+    mult = copy(mults[0])
     mult.init(secp128r1, secp128r1.generator)
     raw = mult.multiply(num)
 
-    asplit = AdditiveSplitting(mult)
-    asplit.init(secp128r1, secp128r1.generator)
-    masked = asplit.multiply(num)
-    assert raw.equals(masked)
+    for mult in mults:
+        asplit = AdditiveSplitting(mult)
+        asplit.init(secp128r1, secp128r1.generator)
+        masked = asplit.multiply(num)
+        assert raw.equals(masked)
 
 
 @pytest.mark.parametrize(
     "num",
     [
-        325385790209017329644351321912443757746,
-        123456789314159265358979323846264338327,
-        987654321314159265358979323846264338327,
-        786877845665557891354654531354008066400,
+        3253857902090173296443513219124437746,
+        1234567893141592653589793238464338327,
     ],
 )
-def test_multiplicative_splitting(mult, secp128r1, num):
+def test_multiplicative_splitting(mults, secp128r1, num):
+    mult = copy(mults[0])
     mult.init(secp128r1, secp128r1.generator)
     raw = mult.multiply(num)
 
-    msplit = MultiplicativeSplitting(mult)
-    msplit.init(secp128r1, secp128r1.generator)
-    masked = msplit.multiply(num)
-    assert raw.equals(masked)
+    for mult in mults:
+        msplit = MultiplicativeSplitting(mult)
+        msplit.init(secp128r1, secp128r1.generator)
+        masked = msplit.multiply(num)
+        assert raw.equals(masked)
 
 
 @pytest.mark.parametrize(
     "num",
     [
-        325385790209017329644351321912443757746,
-        123456789314159265358979323846264338327,
-        987654321314159265358979323846264338327,
-        786877845665557891354654531354008066400,
+        3253857902090173296443513219124437746,
+        1234567893141592653589793238464338327,
     ],
 )
-def test_euclidean_splitting(mult, secp128r1, num):
+def test_euclidean_splitting(mults, secp128r1, num):
+    mult = copy(mults[0])
     mult.init(secp128r1, secp128r1.generator)
     raw = mult.multiply(num)
 
-    esplit = EuclideanSplitting(mult)
-    esplit.init(secp128r1, secp128r1.generator)
-    masked = esplit.multiply(num)
-    assert raw.equals(masked)
+    for mult in mults:
+        esplit = EuclideanSplitting(mult)
+        esplit.init(secp128r1, secp128r1.generator)
+        masked = esplit.multiply(num)
+        assert raw.equals(masked)
diff --git a/test/ec/test_mult.py b/test/ec/test_mult.py
index 721badc..e915585 100644
--- a/test/ec/test_mult.py
+++ b/test/ec/test_mult.py
@@ -361,7 +361,7 @@ def dbl(secp128r1, request):
 
 
 @pytest.mark.parametrize(
-    "num", [10, 2355498743, 325385790209017329644351321912443757746]
+    "num", [10, 2355498743, 3253857902090173296443513219124437746]
 )
 def test_basic_multipliers(secp128r1, num, add, dbl):
     neg = secp128r1.curve.coordinate_model.formulas["neg"]
@@ -451,7 +451,7 @@ def test_basic_multipliers(secp128r1, num, add, dbl):
         for combination in product(*precomp_options.values())
     ]
     bgmw_options = {
-        "width": (3, 5),
+        "width": (2, 3, 5),
         "direction": tuple(ProcessingDirection),
         "accumulation_order": tuple(AccumulationOrder),
     }
@@ -461,7 +461,7 @@ def test_basic_multipliers(secp128r1, num, add, dbl):
         )
         for combination in product(*bgmw_options.values())
     ]
-    comb_options = {"width": (2, 3, 5), "accumulation_order": tuple(AccumulationOrder)}
+    comb_options = {"width": (2, 3, 4, 5), "accumulation_order": tuple(AccumulationOrder)}
     combs = [
         CombMultiplier(
             add, dbl, scl=scale, **dict(zip(comb_options.keys(), combination))