aboutsummaryrefslogtreecommitdiff
path: root/frozen_deps/ecdsa/test_ecdsa.py
diff options
context:
space:
mode:
Diffstat (limited to 'frozen_deps/ecdsa/test_ecdsa.py')
-rw-r--r--frozen_deps/ecdsa/test_ecdsa.py166
1 files changed, 161 insertions, 5 deletions
diff --git a/frozen_deps/ecdsa/test_ecdsa.py b/frozen_deps/ecdsa/test_ecdsa.py
index e656b88..c1e2582 100644
--- a/frozen_deps/ecdsa/test_ecdsa.py
+++ b/frozen_deps/ecdsa/test_ecdsa.py
@@ -21,7 +21,13 @@ from .ecdsa import (
generator_384,
generator_521,
generator_secp256k1,
+ curve_192,
+ InvalidPointError,
+ curve_112r2,
+ generator_112r2,
+ int_to_string,
)
+from .ellipticcurve import Point
HYP_SETTINGS = {}
@@ -71,6 +77,19 @@ class TestP192FromX9_62(unittest.TestCase):
def test_rejection(self):
assert not self.pubk.verifies(self.msg - 1, self.sig)
+ def test_verification_with_regular_point(self):
+ pubk = Public_key(
+ Point(
+ generator_192.curve(),
+ generator_192.x(),
+ generator_192.y(),
+ generator_192.order(),
+ ),
+ self.pubk.point,
+ )
+
+ assert pubk.verifies(self.msg, self.sig)
+
class TestPublicKey(unittest.TestCase):
def test_equality_public_keys(self):
@@ -96,6 +115,20 @@ class TestPublicKey(unittest.TestCase):
pub_key2 = Public_key(gen, point2)
self.assertNotEqual(pub_key1, pub_key2)
+ def test_inequality_different_curves(self):
+ gen = generator_192
+ x1 = 0xC58D61F88D905293BCD4CD0080BCB1B7F811F2FFA41979F6
+ y1 = 0x8804DC7A7C4C7F8B5D437F5156F3312CA7D6DE8A0E11867F
+ point1 = ellipticcurve.Point(gen.curve(), x1, y1)
+
+ x2 = 0x722BA0FB6B8FC8898A4C6AB49E66
+ y2 = 0x2B7344BB57A7ABC8CA0F1A398C7D
+ point2 = ellipticcurve.Point(generator_112r2.curve(), x2, y2)
+
+ pub_key1 = Public_key(gen, point1)
+ pub_key2 = Public_key(generator_112r2, point2)
+ self.assertNotEqual(pub_key1, pub_key2)
+
def test_inequality_public_key_not_implemented(self):
gen = generator_192
x = 0xC58D61F88D905293BCD4CD0080BCB1B7F811F2FFA41979F6
@@ -104,6 +137,106 @@ class TestPublicKey(unittest.TestCase):
pub_key = Public_key(gen, point)
self.assertNotEqual(pub_key, None)
+ def test_public_key_with_generator_without_order(self):
+ gen = ellipticcurve.PointJacobi(
+ generator_192.curve(), generator_192.x(), generator_192.y(), 1
+ )
+
+ x = 0xC58D61F88D905293BCD4CD0080BCB1B7F811F2FFA41979F6
+ y = 0x8804DC7A7C4C7F8B5D437F5156F3312CA7D6DE8A0E11867F
+ point = ellipticcurve.Point(gen.curve(), x, y)
+
+ with self.assertRaises(InvalidPointError) as e:
+ Public_key(gen, point)
+
+ self.assertIn("Generator point must have order", str(e.exception))
+
+ def test_public_point_on_curve_not_scalar_multiple_of_base_point(self):
+ x = 2
+ y = 0xBE6AA4938EF7CFE6FE29595B6B00
+ # we need a curve with cofactor != 1
+ point = ellipticcurve.PointJacobi(curve_112r2, x, y, 1)
+
+ self.assertTrue(curve_112r2.contains_point(x, y))
+
+ with self.assertRaises(InvalidPointError) as e:
+ Public_key(generator_112r2, point)
+
+ self.assertIn("Generator point order", str(e.exception))
+
+ def test_point_is_valid_with_not_scalar_multiple_of_base_point(self):
+ x = 2
+ y = 0xBE6AA4938EF7CFE6FE29595B6B00
+
+ self.assertFalse(point_is_valid(generator_112r2, x, y))
+
+ # the tests to verify the extensiveness of tests in ecdsa.ecdsa
+ # if PointJacobi gets modified to calculate the x and y mod p the tests
+ # below will need to use a fake/mock object
+ def test_invalid_point_x_negative(self):
+ pt = ellipticcurve.PointJacobi(curve_192, -1, 0, 1)
+
+ with self.assertRaises(InvalidPointError) as e:
+ Public_key(generator_192, pt)
+
+ self.assertIn("The public point has x or y", str(e.exception))
+
+ def test_invalid_point_x_equal_p(self):
+ pt = ellipticcurve.PointJacobi(curve_192, curve_192.p(), 0, 1)
+
+ with self.assertRaises(InvalidPointError) as e:
+ Public_key(generator_192, pt)
+
+ self.assertIn("The public point has x or y", str(e.exception))
+
+ def test_invalid_point_y_negative(self):
+ pt = ellipticcurve.PointJacobi(curve_192, 0, -1, 1)
+
+ with self.assertRaises(InvalidPointError) as e:
+ Public_key(generator_192, pt)
+
+ self.assertIn("The public point has x or y", str(e.exception))
+
+ def test_invalid_point_y_equal_p(self):
+ pt = ellipticcurve.PointJacobi(curve_192, 0, curve_192.p(), 1)
+
+ with self.assertRaises(InvalidPointError) as e:
+ Public_key(generator_192, pt)
+
+ self.assertIn("The public point has x or y", str(e.exception))
+
+
+class TestPublicKeyVerifies(unittest.TestCase):
+ # test all the different ways that a signature can be publicly invalid
+ @classmethod
+ def setUpClass(cls):
+ gen = generator_192
+ x = 0xC58D61F88D905293BCD4CD0080BCB1B7F811F2FFA41979F6
+ y = 0x8804DC7A7C4C7F8B5D437F5156F3312CA7D6DE8A0E11867F
+ point = ellipticcurve.Point(gen.curve(), x, y)
+
+ cls.pub_key = Public_key(gen, point)
+
+ def test_sig_with_r_zero(self):
+ sig = Signature(0, 1)
+
+ self.assertFalse(self.pub_key.verifies(1, sig))
+
+ def test_sig_with_r_order(self):
+ sig = Signature(generator_192.order(), 1)
+
+ self.assertFalse(self.pub_key.verifies(1, sig))
+
+ def test_sig_with_s_zero(self):
+ sig = Signature(1, 0)
+
+ self.assertFalse(self.pub_key.verifies(1, sig))
+
+ def test_sig_with_s_order(self):
+ sig = Signature(1, generator_192.order())
+
+ self.assertFalse(self.pub_key.verifies(1, sig))
+
class TestPrivateKey(unittest.TestCase):
@classmethod
@@ -465,7 +598,13 @@ def test_signature_validity(gen, msg, qx, qy, r, s, expected):
elliptic curve of `gen`, `r` and `s` are the signature, and
`expected` is True iff the signature is expected to be valid."""
pubk = Public_key(gen, ellipticcurve.Point(gen.curve(), qx, qy))
- assert expected == pubk.verifies(digest_integer(msg), Signature(r, s))
+ with pytest.warns(DeprecationWarning) as warns:
+ msg_dgst = digest_integer(msg)
+ assert len(warns) == 3
+ assert "unused" in warns[0].message.args[0]
+ assert "unused" in warns[1].message.args[0]
+ assert "unused" in warns[2].message.args[0]
+ assert expected == pubk.verifies(msg_dgst, Signature(r, s))
@pytest.mark.parametrize(
@@ -474,7 +613,13 @@ def test_signature_validity(gen, msg, qx, qy, r, s, expected):
def test_pk_recovery(gen, msg, r, s, qx, qy, expected):
del expected
sign = Signature(r, s)
- pks = sign.recover_public_keys(digest_integer(msg), gen)
+ with pytest.warns(DeprecationWarning) as warns:
+ msg_dgst = digest_integer(msg)
+ assert len(warns) == 3
+ assert "unused" in warns[0].message.args[0]
+ assert "unused" in warns[1].message.args[0]
+ assert "unused" in warns[2].message.args[0]
+ pks = sign.recover_public_keys(msg_dgst, gen)
assert pks
@@ -503,19 +648,22 @@ def st_random_gen_key_msg_nonce(draw):
name = draw(st.sampled_from(sorted(name_gen.keys())))
note("Generator used: {0}".format(name))
generator = name_gen[name]
- order = int(generator.order())
+ order = int(generator.order()) - 1
key = draw(st.integers(min_value=1, max_value=order))
msg = draw(st.integers(min_value=1, max_value=order))
nonce = draw(
- st.integers(min_value=1, max_value=order + 1)
+ st.integers(min_value=1, max_value=order)
| st.integers(min_value=order >> 1, max_value=order)
)
return generator, key, msg, nonce
SIG_VER_SETTINGS = dict(HYP_SETTINGS)
-SIG_VER_SETTINGS["max_examples"] = 10
+if "--fast" in sys.argv: # pragma: no cover
+ SIG_VER_SETTINGS["max_examples"] = 1
+else:
+ SIG_VER_SETTINGS["max_examples"] = 10
@settings(**SIG_VER_SETTINGS)
@@ -536,3 +684,11 @@ def test_sig_verify(args):
assert pubkey.verifies(msg, signature)
assert not pubkey.verifies(msg - 1, signature)
+
+
+def test_int_to_string_with_zero():
+ with pytest.warns(DeprecationWarning) as warns:
+ assert int_to_string(0) == b"\x00"
+
+ assert len(warns) == 1
+ assert "unused" in warns[0].message.args[0]