add test coverage

Author: AntonKueltz

CHANGELOG.md

@@ -4,9 +4,15 @@
 ### Added
 - Support for python3.13
 - `uv` for package management
-- Typing for all modules in this package
+- Typing for all non C extension modules in this package and a corresponding `py.typed` marker
 - Github Actions for testing and publishing
 - Pre-commit hooks to enforce formatting and type checks
+- Functions in `fastedcsa.keys` specific to public and private keys:
+  - `export_private_key`
+  - `export_public_key`
+  - `import_private_key`
+  - `import_public_key`
+- `__self__` to `fastecdsa.curve.Curve`
 
 ### Changed
 - `fastecdsa.encodng.KeyEncoder` interface:
@@ -15,13 +21,14 @@
   - Decoders always take `bytes` for key data
   - Private key methods do not consume or return public key data in their signatures
     - Private key encoding _does_ take a curve parameter as some encoders do encode the public key as part of the encoded private key (in this case the public key is computed using the private key and the curve)
-  -
 
 ### Removed
 - Support for python3.7
 - Support for python3.8
-- `int` tuples are no longer allowed to be passed as `Q` in `ecdsa.verify`. `Q` must be of type `point.Point` now.
-- `keys.export_key` and `keys.import_key`. Superseded by functions specific to public and private keys.
+- `int` tuples are no longer allowed to be passed as `Q` in `fastecdsa.ecdsa.verify`. `Q` must be of type `point.Point` now.
+- `fastecdsa.keys.export_key` and `fastecdsa.keys.import_key`. Superseded by functions specific to public and private keys.
+- Default curve parameter from `fastecdsa.point.Point` constructor
+- `__unicode__` from `fastecdsa.point.Point`
 
 ## [2.3.2]
 ### Added

MANIFEST.in

@@ -1,5 +1,6 @@
 include LICENSE
 include README.rst
+include fastecdsa/py.typed
 include src/_ecdsa.h
 include src/curve.h
 include src/curveMath.h

fastecdsa/curve.py

@@ -64,9 +64,12 @@ def __init__(
         if oid is not None:
             self._oid_lookup[oid] = self
 
-    def __repr__(self) -> str:
+    def __str__(self) -> str:
         return self.name
 
+    def __repr__(self) -> str:
+        return self.__str__()
+
     @classmethod
     def get_curve_by_oid(cls, oid: bytes) -> Optional[Curve]:
         r"""Get a curve via its object identifier.

fastecdsa/ecdsa.py

@@ -127,7 +127,7 @@ def verify(
 def _hex_digest(msg: SignableMessage, hashfunc: HashFunction, prehashed: bool) -> str:
     if prehashed:
         if not isinstance(msg, (bytes, bytearray)):
-            raise ValueError(f"Prehashed message must be bytes, got {type(msg)}")
+            raise TypeError(f"Prehashed message must be bytes, got {type(msg)}")
         return hexlify(msg).decode()
     else:
         return hashfunc(msg_bytes(msg)).hexdigest()

fastecdsa/keys.py

@@ -1,11 +1,11 @@
-from hashlib import sha256
 from os import urandom
-from typing import Optional, Tuple
+from typing import Any, Callable, Optional, Tuple
 
-from .curve import Curve, P256
+from .curve import Curve
 from .ecdsa import verify
 from .encoding import KeyEncoder
 from .point import Point
+from .typing import EcdsaSignature
 from .util import mod_sqrt, msg_bytes
 
 
@@ -29,7 +29,7 @@ def gen_keypair(curve: Curve) -> Tuple[int, Point]:
     return private_key, public_key
 
 
-def gen_private_key(curve: Curve, randfunc=urandom) -> int:
+def gen_private_key(curve: Curve, randfunc: Callable[[Any], bytes] = urandom) -> int:
     """Generate a private key to sign data with.
 
     The private key :math:`d` is an integer generated via a cryptographically secure random number
@@ -82,7 +82,7 @@ def get_public_key(d: int, curve: Curve) -> Point:
 
 
 def get_public_keys_from_sig(
-    sig: Tuple[int, int], msg, curve: Curve = P256, hashfunc=sha256
+    sig: EcdsaSignature, msg, curve: Curve, hashfunc: Callable
 ) -> Tuple[Point, Point]:
     """Recover the public keys that can verify a signature / message pair.
 

fastecdsa/point.py

@@ -1,7 +1,7 @@
 from __future__ import annotations
 
 from fastecdsa import curvemath  # type: ignore
-from .curve import Curve, P256
+from .curve import Curve
 
 
 class CurveMismatchError(Exception):
@@ -20,7 +20,7 @@ class Point:
         |  curve (:class:`Curve`): The curve that the point lies on.
     """
 
-    def __init__(self, x: int, y: int, curve: Curve = P256):
+    def __init__(self, x: int, y: int, curve: Curve):
         r"""Initialize a point on an elliptic curve.
 
         The x and y parameters must satisfy the equation :math:`y^2 \equiv x^3 + ax + b \pmod{p}`,
@@ -54,9 +54,6 @@ def __str__(self) -> str:
         else:
             return f"X: 0x{self.x:x}\nY: 0x{self.y:x}\n(On curve <{self.curve}>)"
 
-    def __unicode__(self) -> str:
-        return self.__str__()
-
     def __repr__(self) -> str:
         return self.__str__()
 

fastecdsa/py.typed

@@ -1,6 +1,6 @@
 [project]
 name = "fastecdsa"
-version = "3.0.0a0"
+version = "3.0.0a1"
 description = "Fast elliptic curve digital signatures"
 readme = "README.rst"
 requires-python = ">=3.9"
@@ -35,6 +35,16 @@ benchmark = "fastecdsa.benchmark:run"
 requires = ["setuptools>=75.6.0"]
 build-backend = "setuptools.build_meta"
 
+[tool.coverage.run]
+omit = [
+    "fastecdsa/benchmark.py",
+    "fastecdsa/encoding/__init__.py"
+]
+
+[tool.pytest.ini_options]
+pythonpath = ["."]
+addopts = "--cov=fastecdsa --cov-report=term-missing --cov-fail-under=95"
+
 [tool.setuptools]
 include-package-data = true
 
@@ -50,4 +60,5 @@ dev = [
     "setuptools>=75.6.0",
     "sphinx-rtd-theme>=3.0.2",
     "sphinx>=7.4.7",
+    "pytest-cov>=6.0.0",
 ]

pyproject.toml

@@ -0,0 +1,14 @@
+from unittest import TestCase
+
+from fastecdsa.curve import Curve
+from fastecdsa.encoding.asn1 import asn1_oid
+
+
+class TestAsn1(TestCase):
+    def test_asn1_oid(self):
+        expected = b""
+
+        curve = Curve("", 0, 0, 0, 0, 0, 0)
+        actual = asn1_oid(curve)
+
+        self.assertEqual(expected, actual)

tests/encoding/test_asn1.py

@@ -0,0 +1,13 @@
+from unittest import TestCase
+
+from fastecdsa.curve import Curve
+
+
+class TestCurve(TestCase):
+    def test_repr(self):
+        expected = "Test Curve"
+
+        curve = Curve(expected, 0, 0, 0, 0, 0, 0)
+        actual = str(curve)
+
+        self.assertEqual(expected, actual)

tests/test_curve.py

@@ -2,7 +2,7 @@
 from unittest import TestCase
 
 from fastecdsa.curve import P256
-from fastecdsa.ecdsa import sign, verify
+from fastecdsa.ecdsa import EcdsaError, sign, verify
 from fastecdsa.point import Point
 
 
@@ -97,3 +97,14 @@ def test_ecdsa_P256_verify(self):
             0x7D1FF961980F961BDAA3233B6209F4013317D3E3F9E1493592DBEAA1AF2BC367,
         )
         self.assertFalse(verify(sig, msg, Q, curve=P256, hashfunc=sha256))
+
+    def test_ecdsa_P256_invalid_Q(self):
+        Q = P256.G
+        Q.x = 0
+
+        with self.assertRaises(EcdsaError):
+            verify((1, 1), "", Q)
+
+    def test_ecdsa_P256_invalid_prehashed_msg_type(self):
+        with self.assertRaises(TypeError):
+            sign("this is a str type", 0x10001, prehashed=True)

tests/test_p256_ecdsa.py

@@ -1,10 +1,50 @@
 from unittest import TestCase
 
-from fastecdsa.curve import W25519
-from fastecdsa.point import Point
+from fastecdsa.curve import P256, W25519
+from fastecdsa.point import CurveMismatchError, Point
 
 
-class TestTypeValidation(TestCase):
+class TestPoint(TestCase):
+    def test_init_invalid_coordinates_point(self):
+        with self.assertRaises(ValueError):
+            Point(0, 1, P256)
+
+    def test_add_different_curves(self):
+        with self.assertRaises(CurveMismatchError):
+            P256.G + W25519.G
+
+    def test_str_reprs(self):
+        expected = (
+            "X: 0x6b17d1f2e12c4247f8bce6e563a440f277037d812deb33a0f4a13945d898c296\n"
+            "Y: 0x4fe342e2fe1a7f9b8ee7eb4a7c0f9e162bce33576b315ececbb6406837bf51f5\n"
+            "(On curve <P256>)"
+        )
+
+        self.assertEqual(expected, str(P256.G))
+        self.assertEqual(expected, repr(P256.G))
+
+        self.assertEqual("<POINT AT INFINITY>", str(Point._identity_element()))
+        self.assertEqual("<POINT AT INFINITY>", repr(Point._identity_element()))
+
+    def test_eq(self):
+        self.assertTrue(P256.G == P256.G)
+        self.assertFalse(P256.G == W25519.G)
+
+        with self.assertRaises(TypeError):
+            P256.G == 2
+
+    def test_sub(self):
+        value = P256.G - P256.G
+
+        self.assertTrue(value._is_identity())
+
+    def test_neg(self):
+        value = Point._identity_element()
+
+        self.assertTrue((-value)._is_identity())
+
+
+class TestPointTypeValidation(TestCase):
     def test_type_validation_add(self):
         with self.assertRaises(TypeError):
             _ = Point._identity_element() + 2  # type: ignore