Move EC tests to pytest fully.

1 files changed, 88 insertions, 71 deletions

diff --git a/test/ec/test_signature.py b/test/ec/test_signature.py
index f6ab302..73e4611 100644
--- a/test/ec/test_signature.py
+++ b/test/ec/test_signature.py
@@ -1,7 +1,7 @@
 from unittest import TestCase
 
 from parameterized import parameterized
-
+import pytest
 from pyecsca.ec.params import get_params
 from pyecsca.ec.mod import Mod
 from pyecsca.ec.mult import LTRMultiplier
@@ -17,81 +17,98 @@ from pyecsca.ec.signature import (
 )
 
 
-class SignatureTests(TestCase):
-    def setUp(self):
-        self.secp128r1 = get_params("secg", "secp128r1", "projective")
-        self.add = self.secp128r1.curve.coordinate_model.formulas["add-2007-bl"]
-        self.dbl = self.secp128r1.curve.coordinate_model.formulas["dbl-2007-bl"]
-        self.mult = LTRMultiplier(self.add, self.dbl)
-        self.msg = 0xCAFEBABE .to_bytes(4, byteorder="big")
-        self.priv = Mod(0xDEADBEEF, self.secp128r1.order)
-        self.mult.init(self.secp128r1, self.secp128r1.generator)
-        self.pub = self.mult.multiply(self.priv.x)
+@pytest.fixture()
+def add(secp128r1):
+    return secp128r1.curve.coordinate_model.formulas["add-2007-bl"]
+
+
+@pytest.fixture()
+def mult(secp128r1, add):
+    dbl = secp128r1.curve.coordinate_model.formulas["dbl-2007-bl"]
+    return LTRMultiplier(add, dbl)
 
-    @parameterized.expand(
-        [
-            ("SHA1", ECDSA_SHA1),
-            ("SHA224", ECDSA_SHA224),
-            ("SHA256", ECDSA_SHA256),
-            ("SHA384", ECDSA_SHA384),
-            ("SHA512", ECDSA_SHA512),
-        ]
-    )
-    def test_all(self, name, algo):
-        signer = algo(self.mult, self.secp128r1, privkey=self.priv)
-        self.assertTrue(signer.can_sign)
-        sig = signer.sign_data(self.msg)
-        verifier = algo(self.mult, self.secp128r1, add=self.add, pubkey=self.pub)
-        self.assertTrue(verifier.can_verify)
-        self.assertTrue(verifier.verify_data(sig, self.msg))
 
-        none = ECDSA_NONE(
-            self.mult, self.secp128r1, add=self.add, pubkey=self.pub, privkey=self.priv
-        )
-        digest = signer.hash_algo(self.msg).digest()
-        sig = none.sign_hash(digest)
-        self.assertTrue(none.verify_hash(sig, digest))
+@pytest.fixture()
+def keypair(secp128r1, mult):
+    priv = Mod(0xDEADBEEF, secp128r1.order)
+    mult.init(secp128r1, secp128r1.generator)
+    pub = mult.multiply(int(priv))
+    return priv, pub
 
-    def test_cannot(self):
-        ok = ECDSA_NONE(
-            self.mult, self.secp128r1, add=self.add, pubkey=self.pub, privkey=self.priv
-        )
-        data = b"aaaa"
-        sig = ok.sign_data(data)
 
-        no_priv = ECDSA_NONE(self.mult, self.secp128r1, pubkey=self.pub)
-        with self.assertRaises(RuntimeError):
-            no_priv.sign_data(data)
-        with self.assertRaises(RuntimeError):
-            no_priv.sign_hash(data)
-        no_pubadd = ECDSA_NONE(self.mult, self.secp128r1, privkey=self.priv)
-        with self.assertRaises(RuntimeError):
-            no_pubadd.verify_data(sig, data)
-        with self.assertRaises(RuntimeError):
-            no_pubadd.verify_hash(sig, data)
+@pytest.fixture()
+def msg():
+    return 0xCAFEBABE.to_bytes(4, byteorder="big")
 
-        with self.assertRaises(ValueError):
-            Signature(self.mult, self.secp128r1)
 
-    @parameterized.expand(
-        [
-            ("SHA1", ECDSA_SHA1),
-            ("SHA224", ECDSA_SHA224),
-            ("SHA256", ECDSA_SHA256),
-            ("SHA384", ECDSA_SHA384),
-            ("SHA512", ECDSA_SHA512),
-        ]
+@pytest.mark.parametrize("name,algo",
+                         [
+                             ("SHA1", ECDSA_SHA1),
+                             ("SHA224", ECDSA_SHA224),
+                             ("SHA256", ECDSA_SHA256),
+                             ("SHA384", ECDSA_SHA384),
+                             ("SHA512", ECDSA_SHA512),
+                         ])
+def test_all(secp128r1, mult, keypair, msg, add, name, algo):
+    priv, pub = keypair
+    signer = algo(mult, secp128r1, privkey=keypair[0])
+    assert signer.can_sign
+    sig = signer.sign_data(msg)
+    verifier = algo(mult, secp128r1, add=add, pubkey=pub)
+    assert verifier.can_verify
+    assert verifier.verify_data(sig, msg)
+
+    none = ECDSA_NONE(
+        mult, secp128r1, add=add, pubkey=pub, privkey=priv
     )
-    def test_fixed_nonce(self, name, algo):
-        signer = algo(self.mult, self.secp128r1, privkey=self.priv)
-        sig_one = signer.sign_data(self.msg, nonce=0xABCDEF)
-        sig_other = signer.sign_data(self.msg, nonce=0xABCDEF)
-        verifier = algo(self.mult, self.secp128r1, add=self.add, pubkey=self.pub)
-        self.assertTrue(verifier.verify_data(sig_one, self.msg))
-        self.assertTrue(verifier.verify_data(sig_other, self.msg))
-        self.assertEqual(sig_one, sig_other)
+    digest = signer.hash_algo(msg).digest()
+    sig = none.sign_hash(digest)
+    assert none.verify_hash(sig, digest)
+
+
+def test_cannot(secp128r1, add, mult, keypair):
+    priv, pub = keypair
+    ok = ECDSA_NONE(
+        mult, secp128r1, add=add, pubkey=pub, privkey=priv
+    )
+    data = b"aaaa"
+    sig = ok.sign_data(data)
+
+    no_priv = ECDSA_NONE(mult, secp128r1, pubkey=pub)
+    with pytest.raises(RuntimeError):
+        no_priv.sign_data(data)
+    with pytest.raises(RuntimeError):
+        no_priv.sign_hash(data)
+    no_pubadd = ECDSA_NONE(mult, secp128r1, privkey=priv)
+    with pytest.raises(RuntimeError):
+        no_pubadd.verify_data(sig, data)
+    with pytest.raises(RuntimeError):
+        no_pubadd.verify_hash(sig, data)
+
+    with pytest.raises(ValueError):
+        Signature(mult, secp128r1)
+
+
+@pytest.mark.parametrize("name,algo",
+                         [
+                             ("SHA1", ECDSA_SHA1),
+                             ("SHA224", ECDSA_SHA224),
+                             ("SHA256", ECDSA_SHA256),
+                             ("SHA384", ECDSA_SHA384),
+                             ("SHA512", ECDSA_SHA512),
+                         ])
+def test_fixed_nonce(secp128r1, mult, keypair, msg, add, name, algo):
+    priv, pub = keypair
+    signer = algo(mult, secp128r1, privkey=priv)
+    sig_one = signer.sign_data(msg, nonce=0xABCDEF)
+    sig_other = signer.sign_data(msg, nonce=0xABCDEF)
+    verifier = algo(mult, secp128r1, add=add, pubkey=pub)
+    assert verifier.verify_data(sig_one, msg)
+    assert verifier.verify_data(sig_other, msg)
+    assert sig_one == sig_other
+
 
-    def test_der(self):
-        sig = SignatureResult(0xAAAAA, 0xBBBBB)
-        self.assertEqual(sig, SignatureResult.from_DER(sig.to_DER()))
-        self.assertNotEqual(sig, "abc")
+def test_der():
+    sig = SignatureResult(0xAAAAA, 0xBBBBB)
+    assert sig == SignatureResult.from_DER(sig.to_DER())
+    assert sig != "abc"