diff options
Diffstat (limited to 'test/ec/test_mult.py')
| -rw-r--r-- | test/ec/test_mult.py | 567 |
1 files changed, 282 insertions, 285 deletions
diff --git a/test/ec/test_mult.py b/test/ec/test_mult.py index 5200520..91ef6dd 100644 --- a/test/ec/test_mult.py +++ b/test/ec/test_mult.py @@ -1,5 +1,6 @@ from unittest import TestCase +import pytest from parameterized import parameterized from pyecsca.ec.params import get_params @@ -13,320 +14,316 @@ from pyecsca.ec.mult import ( DifferentialLadderMultiplier, CoronMultiplier, ) -from pyecsca.ec.point import InfinityPoint +from pyecsca.ec.point import InfinityPoint, Point from .utils import cartesian -class ScalarMultiplierTests(TestCase): - def setUp(self): - self.secp128r1 = get_params("secg", "secp128r1", "projective") - self.base = self.secp128r1.generator - self.coords = self.secp128r1.curve.coordinate_model +def get_formulas(coords, *names): + return [coords.formulas[name] for name in names if name is not None] - self.curve25519 = get_params("other", "Curve25519", "xz") - self.base25519 = self.curve25519.generator - self.coords25519 = self.curve25519.curve.coordinate_model - def get_formulas(self, coords, *names): - return [coords.formulas[name] for name in names if name is not None] +def assert_pt_equality(one: Point, other: Point, scale): + if scale: + assert one == other + else: + assert one.equals(other) - def assertPointEquality(self, one, other, scale): - if scale: - self.assertEqual(one, other) - else: - assert one.equals(other) - def do_basic_test( - self, mult_class, params, base, add, dbl, scale, neg=None, **kwargs - ): - mult = mult_class( - *self.get_formulas(params.curve.coordinate_model, add, dbl, neg, scale), - **kwargs - ) - mult.init(params, base) - res = mult.multiply(314) - other = mult.multiply(157) - mult.init(params, other) - other = mult.multiply(2) - self.assertPointEquality(res, other, scale) - mult.init(params, base) - self.assertEqual(InfinityPoint(params.curve.coordinate_model), mult.multiply(0)) - return res +def do_basic_test( + mult_class, params, base, add, dbl, scale, neg=None, **kwargs +): + mult = mult_class( + *get_formulas(params.curve.coordinate_model, add, dbl, neg, scale), + **kwargs + ) + mult.init(params, base) + res = mult.multiply(314) + other = mult.multiply(157) + mult.init(params, other) + other = mult.multiply(2) + assert_pt_equality(res, other, scale) + mult.init(params, base) + assert InfinityPoint(params.curve.coordinate_model) == mult.multiply(0) + return res + + +@pytest.mark.parametrize("name,add,dbl,scale", + [ + ("scaled", "add-1998-cmo", "dbl-1998-cmo", "z"), + ("complete", "add-2016-rcb", "dbl-2016-rcb", None), + ("none", "add-1998-cmo", "dbl-1998-cmo", None), + ]) +def test_rtl(secp128r1, name, add, dbl, scale): + do_basic_test(RTLMultiplier, secp128r1, secp128r1.generator, add, dbl, scale) - @parameterized.expand( - [ - ("scaled", "add-1998-cmo", "dbl-1998-cmo", "z"), - ("complete", "add-2016-rcb", "dbl-2016-rcb", None), - ("none", "add-1998-cmo", "dbl-1998-cmo", None), - ] + +@pytest.mark.parametrize("name,add,dbl,scale", + [ + ("scaled", "add-1998-cmo", "dbl-1998-cmo", "z"), + ("complete", "add-2016-rcb", "dbl-2016-rcb", None), + ("none", "add-1998-cmo", "dbl-1998-cmo", None), + ]) +def test_ltr(secp128r1, name, add, dbl, scale): + a = do_basic_test( + LTRMultiplier, secp128r1, secp128r1.generator, add, dbl, scale + ) + b = do_basic_test( + LTRMultiplier, secp128r1, secp128r1.generator, add, dbl, scale, always=True + ) + c = do_basic_test( + LTRMultiplier, secp128r1, secp128r1.generator, add, dbl, scale, complete=False ) - def test_rtl(self, name, add, dbl, scale): - self.do_basic_test(RTLMultiplier, self.secp128r1, self.base, add, dbl, scale) + d = do_basic_test( + LTRMultiplier, + secp128r1, + secp128r1.generator, + add, + dbl, + scale, + always=True, + complete=False, + ) + assert_pt_equality(a, b, scale) + assert_pt_equality(b, c, scale) + assert_pt_equality(c, d, scale) + + +@pytest.mark.parametrize("name,add,dbl,scale", + [ + ("scaled", "add-1998-cmo", "dbl-1998-cmo", "z"), + ("complete", "add-2016-rcb", "dbl-2016-rcb", None), + ("none", "add-1998-cmo", "dbl-1998-cmo", None), + ] + ) +def test_coron(secp128r1, name, add, dbl, scale): + do_basic_test(CoronMultiplier, secp128r1, secp128r1.generator, add, dbl, scale) - @parameterized.expand( - [ - ("scaled", "add-1998-cmo", "dbl-1998-cmo", "z"), - ("complete", "add-2016-rcb", "dbl-2016-rcb", None), - ("none", "add-1998-cmo", "dbl-1998-cmo", None), - ] + +def test_ladder(curve25519): + a = do_basic_test( + LadderMultiplier, + curve25519, + curve25519.generator, + "ladd-1987-m", + "dbl-1987-m", + "scale", ) - def test_ltr(self, name, add, dbl, scale): - a = self.do_basic_test( - LTRMultiplier, self.secp128r1, self.base, add, dbl, scale - ) - b = self.do_basic_test( - LTRMultiplier, self.secp128r1, self.base, add, dbl, scale, always=True - ) - c = self.do_basic_test( - LTRMultiplier, self.secp128r1, self.base, add, dbl, scale, complete=False - ) - d = self.do_basic_test( - LTRMultiplier, - self.secp128r1, - self.base, - add, - dbl, - scale, - always=True, - complete=False, - ) - self.assertPointEquality(a, b, scale) - self.assertPointEquality(b, c, scale) - self.assertPointEquality(c, d, scale) + b = do_basic_test( + LadderMultiplier, + curve25519, + curve25519.generator, + "ladd-1987-m", + "dbl-1987-m", + "scale", + complete=False, + ) + assert_pt_equality(a, b, True) + - @parameterized.expand( - [ - ("scaled", "add-1998-cmo", "dbl-1998-cmo", "z"), - ("complete", "add-2016-rcb", "dbl-2016-rcb", None), - ("none", "add-1998-cmo", "dbl-1998-cmo", None), - ] +@pytest.mark.parametrize("name,add,dbl,scale", + [ + ("scaled", "add-1998-cmo", "dbl-1998-cmo", "z"), + ("complete", "add-2016-rcb", "dbl-2016-rcb", None), + ("none", "add-1998-cmo", "dbl-1998-cmo", None), + ]) +def test_simple_ladder(secp128r1, name, add, dbl, scale): + do_basic_test( + SimpleLadderMultiplier, secp128r1, secp128r1.generator, add, dbl, scale ) - def test_coron(self, name, add, dbl, scale): - self.do_basic_test(CoronMultiplier, self.secp128r1, self.base, add, dbl, scale) - def test_ladder(self): - a = self.do_basic_test( - LadderMultiplier, - self.curve25519, - self.base25519, - "ladd-1987-m", - "dbl-1987-m", - "scale", - ) - b = self.do_basic_test( - LadderMultiplier, - self.curve25519, - self.base25519, - "ladd-1987-m", - "dbl-1987-m", - "scale", - complete=False, - ) - self.assertPointEquality(a, b, True) - @parameterized.expand( - [ - ("scaled", "add-1998-cmo", "dbl-1998-cmo", "z"), - ("complete", "add-2016-rcb", "dbl-2016-rcb", None), - ("none", "add-1998-cmo", "dbl-1998-cmo", None), - ] +@pytest.mark.parametrize("name,num,complete", + [ + ("15", 15, True), + ("15", 15, False), + ("2355498743", 2355498743, True), + ("2355498743", 2355498743, False), + ( + "325385790209017329644351321912443757746", + 325385790209017329644351321912443757746, + True, + ), + ( + "325385790209017329644351321912443757746", + 325385790209017329644351321912443757746, + False, + ), + ]) +def test_ladder_differential(curve25519, name, num, complete): + ladder = LadderMultiplier( + curve25519.curve.coordinate_model.formulas["ladd-1987-m"], + curve25519.curve.coordinate_model.formulas["dbl-1987-m"], + curve25519.curve.coordinate_model.formulas["scale"], + complete=complete, ) - def test_simple_ladder(self, name, add, dbl, scale): - self.do_basic_test( - SimpleLadderMultiplier, self.secp128r1, self.base, add, dbl, scale - ) + differential = DifferentialLadderMultiplier( + curve25519.curve.coordinate_model.formulas["dadd-1987-m"], + curve25519.curve.coordinate_model.formulas["dbl-1987-m"], + curve25519.curve.coordinate_model.formulas["scale"], + complete=complete, + ) + ladder.init(curve25519, curve25519.generator) + res_ladder = ladder.multiply(num) + differential.init(curve25519, curve25519.generator) + res_differential = differential.multiply(num) + assert res_ladder == res_differential + assert InfinityPoint(curve25519.curve.coordinate_model) == differential.multiply(0) + - @parameterized.expand( - [ - ("15", 15, True), - ("15", 15, False), - ("2355498743", 2355498743, True), - ("2355498743", 2355498743, False), - ( - "325385790209017329644351321912443757746", - 325385790209017329644351321912443757746, - True, - ), - ( - "325385790209017329644351321912443757746", - 325385790209017329644351321912443757746, - False, - ), - ] +@pytest.mark.parametrize("name,add,dbl,neg,scale", + [ + ("scaled", "add-1998-cmo", "dbl-1998-cmo", "neg", "z"), + ("complete", "add-2016-rcb", "dbl-2016-rcb", "neg", None), + ("none", "add-1998-cmo", "dbl-1998-cmo", "neg", None), + ]) +def test_binary_naf(secp128r1, name, add, dbl, neg, scale): + do_basic_test( + BinaryNAFMultiplier, secp128r1, secp128r1.generator, add, dbl, scale, neg ) - def test_ladder_differential(self, name, num, complete): - ladder = LadderMultiplier( - self.coords25519.formulas["ladd-1987-m"], - self.coords25519.formulas["dbl-1987-m"], - self.coords25519.formulas["scale"], - complete=complete, - ) - differential = DifferentialLadderMultiplier( - self.coords25519.formulas["dadd-1987-m"], - self.coords25519.formulas["dbl-1987-m"], - self.coords25519.formulas["scale"], - complete=complete, - ) - 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)) - @parameterized.expand( - [ - ("scaled", "add-1998-cmo", "dbl-1998-cmo", "neg", "z"), - ("complete", "add-2016-rcb", "dbl-2016-rcb", "neg", None), - ("none", "add-1998-cmo", "dbl-1998-cmo", "neg", None), - ] + +@pytest.mark.parametrize("name,add,dbl,neg,width,scale", + [ + ("scaled3", "add-1998-cmo", "dbl-1998-cmo", "neg", 3, "z"), + ("none3", "add-1998-cmo", "dbl-1998-cmo", "neg", 3, None), + ("complete3", "add-2016-rcb", "dbl-2016-rcb", "neg", 3, None), + ("scaled5", "add-1998-cmo", "dbl-1998-cmo", "neg", 5, "z"), + ("none5", "add-1998-cmo", "dbl-1998-cmo", "neg", 5, None), + ("complete5", "add-2016-rcb", "dbl-2016-rcb", "neg", 5, None), + ]) +def test_window_naf(secp128r1, name, add, dbl, neg, width, scale): + formulas = get_formulas(secp128r1.curve.coordinate_model, add, dbl, neg, scale) + mult = WindowNAFMultiplier(*formulas[:3], width, *formulas[3:]) + mult.init(secp128r1, secp128r1.generator) + res = mult.multiply(157 * 789) + other = mult.multiply(157) + mult.init(secp128r1, other) + other = mult.multiply(789) + assert_pt_equality(res, other, scale) + mult.init(secp128r1, secp128r1.generator) + assert InfinityPoint(secp128r1.curve.coordinate_model) == mult.multiply(0) + + mult = WindowNAFMultiplier( + *formulas[:3], width, *formulas[3:], precompute_negation=True ) - def test_binary_naf(self, name, add, dbl, neg, scale): - self.do_basic_test( - BinaryNAFMultiplier, self.secp128r1, self.base, add, dbl, scale, neg - ) + mult.init(secp128r1, secp128r1.generator) + res_precompute = mult.multiply(157 * 789) + assert_pt_equality(res_precompute, res, scale) + - @parameterized.expand( - [ - ("scaled3", "add-1998-cmo", "dbl-1998-cmo", "neg", 3, "z"), - ("none3", "add-1998-cmo", "dbl-1998-cmo", "neg", 3, None), - ("complete3", "add-2016-rcb", "dbl-2016-rcb", "neg", 3, None), - ("scaled5", "add-1998-cmo", "dbl-1998-cmo", "neg", 5, "z"), - ("none5", "add-1998-cmo", "dbl-1998-cmo", "neg", 5, None), - ("complete5", "add-2016-rcb", "dbl-2016-rcb", "neg", 5, None), - ] +@pytest.mark.parametrize("name,num,add,dbl", + cartesian( + [ + ("10", 10), + ("2355498743", 2355498743), + ( + "325385790209017329644351321912443757746", + 325385790209017329644351321912443757746, + ), + ], + [("add-1998-cmo", "dbl-1998-cmo"), ("add-2016-rcb", "dbl-2016-rcb")], + ) + ) +def test_basic_multipliers(secp128r1, name, num, add, dbl): + ltr = LTRMultiplier( + secp128r1.curve.coordinate_model.formulas[add], + secp128r1.curve.coordinate_model.formulas[dbl], + secp128r1.curve.coordinate_model.formulas["z"], + ) + with pytest.raises(ValueError): + ltr.multiply(1) + ltr.init(secp128r1, secp128r1.generator) + res_ltr = ltr.multiply(num) + rtl = RTLMultiplier( + secp128r1.curve.coordinate_model.formulas[add], + secp128r1.curve.coordinate_model.formulas["dbl-1998-cmo"], + secp128r1.curve.coordinate_model.formulas["z"], ) - def test_window_naf(self, name, add, dbl, neg, width, scale): - formulas = self.get_formulas(self.coords, add, dbl, neg, scale) - mult = WindowNAFMultiplier(*formulas[:3], width, *formulas[3:]) - mult.init(self.secp128r1, self.base) - res = mult.multiply(157 * 789) - other = mult.multiply(157) - mult.init(self.secp128r1, other) - other = mult.multiply(789) - self.assertPointEquality(res, other, scale) - mult.init(self.secp128r1, self.base) - self.assertEqual(InfinityPoint(self.coords), mult.multiply(0)) + with pytest.raises(ValueError): + rtl.multiply(1) + rtl.init(secp128r1, secp128r1.generator) + res_rtl = rtl.multiply(num) + assert res_ltr == res_rtl - mult = WindowNAFMultiplier( - *formulas[:3], width, *formulas[3:], precompute_negation=True - ) - mult.init(self.secp128r1, self.base) - res_precompute = mult.multiply(157 * 789) - self.assertPointEquality(res_precompute, res, scale) + ltr_always = LTRMultiplier( + secp128r1.curve.coordinate_model.formulas[add], + secp128r1.curve.coordinate_model.formulas[dbl], + secp128r1.curve.coordinate_model.formulas["z"], + always=True, + ) + rtl_always = RTLMultiplier( + secp128r1.curve.coordinate_model.formulas[add], + secp128r1.curve.coordinate_model.formulas[dbl], + secp128r1.curve.coordinate_model.formulas["z"], + always=True, + ) + ltr_always.init(secp128r1, secp128r1.generator) + rtl_always.init(secp128r1, secp128r1.generator) + res_ltr_always = ltr_always.multiply(num) + res_rtl_always = rtl_always.multiply(num) + assert res_ltr == res_ltr_always + assert res_rtl == res_rtl_always - @parameterized.expand( - cartesian( - [ - ("10", 10), - ("2355498743", 2355498743), - ( - "325385790209017329644351321912443757746", - 325385790209017329644351321912443757746, - ), - ], - [("add-1998-cmo", "dbl-1998-cmo"), ("add-2016-rcb", "dbl-2016-rcb")], - ) + bnaf = BinaryNAFMultiplier( + secp128r1.curve.coordinate_model.formulas[add], + secp128r1.curve.coordinate_model.formulas[dbl], + secp128r1.curve.coordinate_model.formulas["neg"], + secp128r1.curve.coordinate_model.formulas["z"], ) - def test_basic_multipliers(self, name, num, add, dbl): - ltr = LTRMultiplier( - self.coords.formulas[add], - self.coords.formulas[dbl], - self.coords.formulas["z"], - ) - with self.assertRaises(ValueError): - ltr.multiply(1) - ltr.init(self.secp128r1, self.base) - res_ltr = ltr.multiply(num) - rtl = RTLMultiplier( - self.coords.formulas[add], - self.coords.formulas["dbl-1998-cmo"], - self.coords.formulas["z"], - ) - with self.assertRaises(ValueError): - rtl.multiply(1) - rtl.init(self.secp128r1, self.base) - res_rtl = rtl.multiply(num) - self.assertEqual(res_ltr, res_rtl) + with pytest.raises(ValueError): + bnaf.multiply(1) + bnaf.init(secp128r1, secp128r1.generator) + res_bnaf = bnaf.multiply(num) + assert res_bnaf == res_ltr - ltr_always = LTRMultiplier( - self.coords.formulas[add], - self.coords.formulas[dbl], - self.coords.formulas["z"], - always=True, - ) - rtl_always = RTLMultiplier( - self.coords.formulas[add], - self.coords.formulas[dbl], - self.coords.formulas["z"], - always=True, - ) - 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) + wnaf = WindowNAFMultiplier( + secp128r1.curve.coordinate_model.formulas[add], + secp128r1.curve.coordinate_model.formulas[dbl], + secp128r1.curve.coordinate_model.formulas["neg"], + 3, + secp128r1.curve.coordinate_model.formulas["z"], + ) + with pytest.raises(ValueError): + wnaf.multiply(1) + wnaf.init(secp128r1, secp128r1.generator) + res_wnaf = wnaf.multiply(num) + assert res_wnaf == res_ltr - bnaf = BinaryNAFMultiplier( - self.coords.formulas[add], - self.coords.formulas[dbl], - self.coords.formulas["neg"], - self.coords.formulas["z"], - ) - with self.assertRaises(ValueError): - bnaf.multiply(1) - bnaf.init(self.secp128r1, self.base) - res_bnaf = bnaf.multiply(num) - self.assertEqual(res_bnaf, res_ltr) + ladder = SimpleLadderMultiplier( + secp128r1.curve.coordinate_model.formulas[add], + secp128r1.curve.coordinate_model.formulas[dbl], + secp128r1.curve.coordinate_model.formulas["z"], + ) + with pytest.raises(ValueError): + ladder.multiply(1) + ladder.init(secp128r1, secp128r1.generator) + res_ladder = ladder.multiply(num) + assert res_ladder == res_ltr - wnaf = WindowNAFMultiplier( - self.coords.formulas[add], - self.coords.formulas[dbl], - self.coords.formulas["neg"], - 3, - self.coords.formulas["z"], - ) - with self.assertRaises(ValueError): - wnaf.multiply(1) - wnaf.init(self.secp128r1, self.base) - res_wnaf = wnaf.multiply(num) - self.assertEqual(res_wnaf, res_ltr) + coron = CoronMultiplier( + secp128r1.curve.coordinate_model.formulas[add], + secp128r1.curve.coordinate_model.formulas[dbl], + secp128r1.curve.coordinate_model.formulas["z"], + ) + with pytest.raises(ValueError): + coron.multiply(1) + coron.init(secp128r1, secp128r1.generator) + res_coron = coron.multiply(num) + assert res_coron == res_ltr - ladder = SimpleLadderMultiplier( - self.coords.formulas[add], - self.coords.formulas[dbl], - self.coords.formulas["z"], - ) - with self.assertRaises(ValueError): - ladder.multiply(1) - ladder.init(self.secp128r1, self.base) - res_ladder = ladder.multiply(num) - self.assertEqual(res_ladder, res_ltr) - coron = CoronMultiplier( - self.coords.formulas[add], - self.coords.formulas[dbl], - self.coords.formulas["z"], - ) - with self.assertRaises(ValueError): - coron.multiply(1) - coron.init(self.secp128r1, self.base) - res_coron = coron.multiply(num) - self.assertEqual(res_coron, res_ltr) +def test_init_fail(curve25519, secp128r1): + mult = DifferentialLadderMultiplier( + curve25519.curve.coordinate_model.formulas["dadd-1987-m"], + curve25519.curve.coordinate_model.formulas["dbl-1987-m"], + curve25519.curve.coordinate_model.formulas["scale"], + ) + with pytest.raises(ValueError): + mult.init(secp128r1, secp128r1.generator) - def test_init_fail(self): - mult = DifferentialLadderMultiplier( - self.coords25519.formulas["dadd-1987-m"], - self.coords25519.formulas["dbl-1987-m"], - self.coords25519.formulas["scale"], + with pytest.raises(ValueError): + LadderMultiplier( + curve25519.curve.coordinate_model.formulas["ladd-1987-m"], + scl=curve25519.curve.coordinate_model.formulas["scale"], + complete=False, ) - with self.assertRaises(ValueError): - mult.init(self.secp128r1, self.base) - - with self.assertRaises(ValueError): - LadderMultiplier( - self.coords25519.formulas["ladd-1987-m"], - scl=self.coords25519.formulas["scale"], - complete=False, - ) |