Add AbelianGroup class.

5 files changed, 54 insertions, 73 deletions

diff --git a/test/ec/curves.py b/test/ec/curves.py
index d36e702..c7453c7 100644
--- a/test/ec/curves.py
+++ b/test/ec/curves.py
@@ -1,26 +1,29 @@
 from pyecsca.ec.curve import EllipticCurve
+from pyecsca.ec.group import AbelianGroup
 from pyecsca.ec.mod import Mod
 from pyecsca.ec.model import ShortWeierstrassModel, MontgomeryModel
-from pyecsca.ec.point import InfinityPoint, Point
+from pyecsca.ec.point import Point, InfinityPoint
 
 
 def get_secp128r1():
     prime = 0xfffffffdffffffffffffffffffffffff
     model = ShortWeierstrassModel()
-    coords = ShortWeierstrassModel().coordinates["projective"]
-    return (EllipticCurve(model, coords, prime, dict(a=0xfffffffdfffffffffffffffffffffffc,
-                                                     b=0xe87579c11079f43dd824993c2cee5ed3),
-                          InfinityPoint(coords)),
-            Point(coords, X=Mod(0x161ff7528b899b2d0c28607ca52c5b86, prime),
-                  Y=Mod(0xcf5ac8395bafeb13c02da292dded7a83, prime),
-                  Z=Mod(1, prime)))
+    coords = model.coordinates["projective"]
+    curve = EllipticCurve(model, coords, prime, dict(a=0xfffffffdfffffffffffffffffffffffc,
+                                                     b=0xe87579c11079f43dd824993c2cee5ed3))
+    return AbelianGroup(curve, Point(coords, X=Mod(0x161ff7528b899b2d0c28607ca52c5b86, prime),
+                                     Y=Mod(0xcf5ac8395bafeb13c02da292dded7a83, prime),
+                                     Z=Mod(1, prime)), InfinityPoint(coords),
+                        order=0xfffffffe0000000075a30d1b9038a115, cofactor=1)
 
 
 def get_curve25519():
     prime = 0x7fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffed
     model = MontgomeryModel()
     coords = model.coordinates["xz"]
-    return (EllipticCurve(model, coords, prime,
-                          dict(a=486662, b=1),
-                          InfinityPoint(coords)),
-            Point(coords, X=Mod(9, prime), Z=Mod(1, prime)))
+    curve = EllipticCurve(model, coords, prime,
+                          dict(a=486662, b=1))
+    return AbelianGroup(curve, Point(coords, X=Mod(9, prime), Z=Mod(1, prime)),
+                        InfinityPoint(coords),
+                        order=0x1000000000000000000000000000000014DEF9DEA2F79CD65812631A5CF5D3ED,
+                        cofactor=2)
diff --git a/test/ec/test_coordinates.py b/test/ec/test_coordinates.py
deleted file mode 100644
index 31f3edf..0000000
--- a/test/ec/test_coordinates.py
+++ /dev/null
@@ -1,24 +0,0 @@
-from unittest import TestCase
-
-from pyecsca.ec.curve import EllipticCurve
-from pyecsca.ec.mod import Mod
-from pyecsca.ec.model import ShortWeierstrassModel
-from pyecsca.ec.point import Point, InfinityPoint
-
-
-class CoordinateTests(TestCase):
-
-    def setUp(self):
-        self.p = 0xfffffffdffffffffffffffffffffffff
-        self.coords = ShortWeierstrassModel().coordinates["projective"]
-        self.secp128r1 = EllipticCurve(ShortWeierstrassModel(), self.coords, self.p,
-                                       dict(a=0xfffffffdfffffffffffffffffffffffc,
-                                            b=0xe87579c11079f43dd824993c2cee5ed3),
-                                       InfinityPoint(self.coords))
-
-    def test_affine(self):
-        pt = Point(self.coords, X=Mod(0x161ff7528b899b2d0c28607ca52c5b86, self.p),
-                   Y=Mod(0xcf5ac8395bafeb13c02da292dded7a83, self.p),
-                   Z=Mod(1, self.p))
-        affine_Point = pt.to_affine()
-        assert pt.equals(affine_Point)
diff --git a/test/ec/test_curve.py b/test/ec/test_curve.py
index 7e8e7eb..382d144 100644
--- a/test/ec/test_curve.py
+++ b/test/ec/test_curve.py
@@ -1,20 +1,18 @@
 from unittest import TestCase
 
 from pyecsca.ec.mod import Mod
-from pyecsca.ec.point import Point, InfinityPoint
+from pyecsca.ec.point import Point
 from test.ec.curves import get_secp128r1
 
 
 class CurveTests(TestCase):
     def setUp(self):
-        self.secp128r1, self.base = get_secp128r1()
+        self.secp128r1 = get_secp128r1()
+        self.base = self.secp128r1.generator
 
     def test_is_on_curve(self):
-        pt = Point(self.secp128r1.coordinate_model,
-                   X=Mod(0x161ff7528b899b2d0c28607ca52c5b86, self.secp128r1.prime),
-                   Y=Mod(0xcf5ac8395bafeb13c02da292dded7a83, self.secp128r1.prime),
-                   Z=Mod(1, self.secp128r1.prime))
-        assert self.secp128r1.is_on_curve(pt)
-
-    def test_is_neutral(self):
-        assert self.secp128r1.is_neutral(InfinityPoint(self.secp128r1.coordinate_model))
+        pt = Point(self.secp128r1.curve.coordinate_model,
+                   X=Mod(0x161ff7528b899b2d0c28607ca52c5b86, self.secp128r1.curve.prime),
+                   Y=Mod(0xcf5ac8395bafeb13c02da292dded7a83, self.secp128r1.curve.prime),
+                   Z=Mod(1, self.secp128r1.curve.prime))
+        assert self.secp128r1.curve.is_on_curve(pt)
diff --git a/test/ec/test_mult.py b/test/ec/test_mult.py
index 8a82e3a..2d167f3 100644
--- a/test/ec/test_mult.py
+++ b/test/ec/test_mult.py
@@ -9,11 +9,13 @@ from test.ec.curves import get_secp128r1, get_curve25519
 class ScalarMultiplierTests(TestCase):
 
     def setUp(self):
-        self.secp128r1, self.base = get_secp128r1()
-        self.coords = self.secp128r1.coordinate_model
+        self.secp128r1 = get_secp128r1()
+        self.base = self.secp128r1.generator
+        self.coords = self.secp128r1.curve.coordinate_model
 
-        self.curve25519, self.base25519 = get_curve25519()
-        self.coords25519 = self.curve25519.coordinate_model
+        self.curve25519 = get_curve25519()
+        self.base25519 = self.curve25519.generator
+        self.coords25519 = self.curve25519.curve.coordinate_model
 
     def test_rtl(self):
         mult = RTLMultiplier(self.secp128r1, self.coords.formulas["add-1998-cmo"],
diff --git a/test/ec/test_point.py b/test/ec/test_point.py
index a89a44f..a59204b 100644
--- a/test/ec/test_point.py
+++ b/test/ec/test_point.py
@@ -9,14 +9,16 @@ from test.ec.curves import get_secp128r1
 
 class PointTests(TestCase):
     def setUp(self):
-        self.secp128r1, self.base = get_secp128r1()
+        self.secp128r1 = get_secp128r1()
+        self.base = self.secp128r1.generator
+        self.coords = self.secp128r1.curve.coordinate_model
         self.affine = AffineCoordinateModel(ShortWeierstrassModel())
 
     def test_to_affine(self):
-        pt = Point(self.secp128r1.coordinate_model,
-                   X=Mod(0x161ff7528b899b2d0c28607ca52c5b86, self.secp128r1.prime),
-                   Y=Mod(0xcf5ac8395bafeb13c02da292dded7a83, self.secp128r1.prime),
-                   Z=Mod(1, self.secp128r1.prime))
+        pt = Point(self.coords,
+                   X=Mod(0x161ff7528b899b2d0c28607ca52c5b86, self.secp128r1.curve.prime),
+                   Y=Mod(0xcf5ac8395bafeb13c02da292dded7a83, self.secp128r1.curve.prime),
+                   Z=Mod(1, self.secp128r1.curve.prime))
         affine = pt.to_affine()
 
         self.assertIsInstance(affine.coordinate_model, AffineCoordinateModel)
@@ -24,37 +26,37 @@ class PointTests(TestCase):
         self.assertEqual(affine.coords["x"], pt.coords["X"])
         self.assertEqual(affine.coords["y"], pt.coords["Y"])
 
-        affine = InfinityPoint(self.secp128r1.coordinate_model).to_affine()
+        affine = InfinityPoint(self.coords).to_affine()
         self.assertIsInstance(affine, InfinityPoint)
 
     def test_from_affine(self):
-        affine = Point(self.affine, x=Mod(0xabcd, self.secp128r1.prime),
-                       y=Mod(0xef, self.secp128r1.prime))
-        projective_model = self.secp128r1.coordinate_model
+        affine = Point(self.affine, x=Mod(0xabcd, self.secp128r1.curve.prime),
+                       y=Mod(0xef, self.secp128r1.curve.prime))
+        projective_model = self.coords
         other = Point.from_affine(projective_model, affine)
 
         self.assertEqual(other.coordinate_model, projective_model)
         self.assertSetEqual(set(other.coords.keys()), set(projective_model.variables))
         self.assertEqual(other.coords["X"], affine.coords["x"])
         self.assertEqual(other.coords["Y"], affine.coords["y"])
-        self.assertEqual(other.coords["Z"], Mod(1, self.secp128r1.prime))
+        self.assertEqual(other.coords["Z"], Mod(1, self.secp128r1.curve.prime))
 
     def test_to_from_affine(self):
-        pt = Point(self.secp128r1.coordinate_model,
-                   X=Mod(0x161ff7528b899b2d0c28607ca52c5b86, self.secp128r1.prime),
-                   Y=Mod(0xcf5ac8395bafeb13c02da292dded7a83, self.secp128r1.prime),
-                   Z=Mod(1, self.secp128r1.prime))
-        other = Point.from_affine(self.secp128r1.coordinate_model, pt.to_affine())
+        pt = Point(self.coords,
+                   X=Mod(0x161ff7528b899b2d0c28607ca52c5b86, self.secp128r1.curve.prime),
+                   Y=Mod(0xcf5ac8395bafeb13c02da292dded7a83, self.secp128r1.curve.prime),
+                   Z=Mod(1, self.secp128r1.curve.prime))
+        other = Point.from_affine(self.coords, pt.to_affine())
         self.assertEqual(pt, other)
 
     def test_equals(self):
-        pt = Point(self.secp128r1.coordinate_model,
-                   X=Mod(0x4, self.secp128r1.prime),
-                   Y=Mod(0x6, self.secp128r1.prime),
-                   Z=Mod(2, self.secp128r1.prime))
-        other = Point(self.secp128r1.coordinate_model,
-                      X=Mod(0x2, self.secp128r1.prime),
-                      Y=Mod(0x3, self.secp128r1.prime),
-                      Z=Mod(1, self.secp128r1.prime))
+        pt = Point(self.coords,
+                   X=Mod(0x4, self.secp128r1.curve.prime),
+                   Y=Mod(0x6, self.secp128r1.curve.prime),
+                   Z=Mod(2, self.secp128r1.curve.prime))
+        other = Point(self.coords,
+                      X=Mod(0x2, self.secp128r1.curve.prime),
+                      Y=Mod(0x3, self.secp128r1.curve.prime),
+                      Z=Mod(1, self.secp128r1.curve.prime))
         assert pt.equals(other)
         self.assertNotEquals(pt, other)