lightphe 0.0.10__tar.gz → 0.0.11__tar.gz

{lightphe-0.0.10 → lightphe-0.0.11}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: lightphe
-Version: 0.0.10
+Version: 0.0.11
 Summary: A Lightweight Partially Homomorphic Encryption Library for Python
 Home-page: https://github.com/serengil/LightPHE
 Author: Sefik Ilkin Serengil
@@ -22,7 +22,8 @@ License-File: LICENSE
 [![Stars](https://img.shields.io/github/stars/serengil/LightPHE?color=yellow&style=flat&label=%E2%AD%90%20stars)](https://github.com/serengil/LightPHE/stargazers)
 [![Tests](https://github.com/serengil/LightPHE/actions/workflows/tests.yml/badge.svg)](https://github.com/serengil/LightPHE/actions/workflows/tests.yml)
 [![License](http://img.shields.io/:license-MIT-green.svg?style=flat)](https://github.com/serengil/LightPHE/blob/master/LICENSE)
-[![DOI](http://img.shields.io/:DOI-10.48550/arXiv.2408.05219-blue.svg?style=flat)](https://arxiv.org/abs/2408.05219)
+[![arXiv](https://img.shields.io/badge/arXiv-2408.05219-b31b1b.svg?logo=arXiv)](https://arxiv.org/abs/2408.05219)
+<!-- [![DOI](http://img.shields.io/:DOI-10.48550/arXiv.2408.05219-blue.svg?style=flat)](https://arxiv.org/abs/2408.05219) -->
 
 [![Blog](https://img.shields.io/:blog-sefiks.com-blue.svg?style=flat&logo=wordpress)](https://sefiks.com)
 [![YouTube](https://img.shields.io/:youtube-@sefiks-red.svg?style=flat&logo=youtube)](https://www.youtube.com/@sefiks?sub_confirmation=1)
@@ -245,23 +246,39 @@ with pytest.raises(ValueError, match="Paillier is not homomorphic with respect t
 
 However, if you tried to multiply ciphertexts with RSA, or xor ciphertexts with Goldwasser-Micali, these will be succeeded because those cryptosystems support those homomorphic operations.
 
-### Elliptic Curve Cryptography
+### Elliptic Curve Cryptography
 
-ECC is a powerful public-key cryptosystem based on the algebraic structure of elliptic curves over finite fields. In LightPHE, the [Elliptic Curve ElGamal](https://sefiks.com/2018/08/21/elliptic-curve-elgamal-encryption/) scheme is implemented, offering a secure and efficient homomorphic encryption option. The library supports 100+ standard elliptic curves.
+ECC is a powerful public-key cryptosystem based on the algebraic structure of elliptic curves over finite fields. The library supports 3 elliptic curve forms (weierstrass, edwards and koblitz) and 100+ standard elliptic curve configurations.
+
+Building an elliptic curve with LightPHE is very straightforward. Once the curve is initialized, you can perform operations such as point addition and scalar multiplication.
 
 ```python
-some_curves = [
-    {"form": "weierstrass", "curve": "secp256k1"},
-    {"form": "edwards", "curve": "ed25519"},
-    {"form": "koblitz", "curve": "k163"}
-]
+from lightphe import ECC
+
+forms = ["weierstrass", "edwards", "koblitz"]
+
+# construct an elliptic curve
+ed = ECC(form_name="edwards")
+
+# Base Point
+G = ed.G
 
-curve = some_curves[1]
+_2G = G + G
+_3G = _2G + G
+_5G = _3G + _2G
+
+_20G = 4 * G
+_19G = _20G - G
+```
+
+In LightPHE, the [Elliptic Curve ElGamal](https://sefiks.com/2018/08/21/elliptic-curve-elgamal-encryption/) scheme is implemented, offering a secure and efficient homomorphic encryption option.
+
+```python
+forms = ["weierstass", "edwards", "koblitz"]
 
 phe = LightPHE(
     algorithm_name="EllipticCurve-ElGamal",
-    form=curve["form"],
-    curve=curve["curve"],
+    form=forms[1],
 )
 ```
 
@@ -269,7 +286,7 @@ One of the crucial factors that define the security level of an elliptic curve c
 
 Each curve in LightPHE has a specific order, which is carefully chosen to balance performance and security. By selecting an elliptic curve with a larger order, you increase the security of your cryptographic system, but this may come with a trade-off in computational efficiency. Therefore, choosing the appropriate curve order is a crucial decision based on your application’s security and performance requirements.
 
-See [`Curves`](https://github.com/serengil/LightPHE/tree/master/lightphe/elliptic_curve_forms) page for more details.
+See [`curves`](https://github.com/serengil/LightPHE/tree/master/lightphe/elliptic_curve_forms) page for a list of all supported forms, curves and their details.
 
 # Contributing
 

{lightphe-0.0.10 → lightphe-0.0.11}/README.md

@@ -6,7 +6,8 @@
 [![Stars](https://img.shields.io/github/stars/serengil/LightPHE?color=yellow&style=flat&label=%E2%AD%90%20stars)](https://github.com/serengil/LightPHE/stargazers)
 [![Tests](https://github.com/serengil/LightPHE/actions/workflows/tests.yml/badge.svg)](https://github.com/serengil/LightPHE/actions/workflows/tests.yml)
 [![License](http://img.shields.io/:license-MIT-green.svg?style=flat)](https://github.com/serengil/LightPHE/blob/master/LICENSE)
-[![DOI](http://img.shields.io/:DOI-10.48550/arXiv.2408.05219-blue.svg?style=flat)](https://arxiv.org/abs/2408.05219)
+[![arXiv](https://img.shields.io/badge/arXiv-2408.05219-b31b1b.svg?logo=arXiv)](https://arxiv.org/abs/2408.05219)
+<!-- [![DOI](http://img.shields.io/:DOI-10.48550/arXiv.2408.05219-blue.svg?style=flat)](https://arxiv.org/abs/2408.05219) -->
 
 [![Blog](https://img.shields.io/:blog-sefiks.com-blue.svg?style=flat&logo=wordpress)](https://sefiks.com)
 [![YouTube](https://img.shields.io/:youtube-@sefiks-red.svg?style=flat&logo=youtube)](https://www.youtube.com/@sefiks?sub_confirmation=1)
@@ -229,23 +230,39 @@ with pytest.raises(ValueError, match="Paillier is not homomorphic with respect t
 
 However, if you tried to multiply ciphertexts with RSA, or xor ciphertexts with Goldwasser-Micali, these will be succeeded because those cryptosystems support those homomorphic operations.
 
-### Elliptic Curve Cryptography
+### Elliptic Curve Cryptography
 
-ECC is a powerful public-key cryptosystem based on the algebraic structure of elliptic curves over finite fields. In LightPHE, the [Elliptic Curve ElGamal](https://sefiks.com/2018/08/21/elliptic-curve-elgamal-encryption/) scheme is implemented, offering a secure and efficient homomorphic encryption option. The library supports 100+ standard elliptic curves.
+ECC is a powerful public-key cryptosystem based on the algebraic structure of elliptic curves over finite fields. The library supports 3 elliptic curve forms (weierstrass, edwards and koblitz) and 100+ standard elliptic curve configurations.
+
+Building an elliptic curve with LightPHE is very straightforward. Once the curve is initialized, you can perform operations such as point addition and scalar multiplication.
 
 ```python
-some_curves = [
-    {"form": "weierstrass", "curve": "secp256k1"},
-    {"form": "edwards", "curve": "ed25519"},
-    {"form": "koblitz", "curve": "k163"}
-]
+from lightphe import ECC
+
+forms = ["weierstrass", "edwards", "koblitz"]
+
+# construct an elliptic curve
+ed = ECC(form_name="edwards")
+
+# Base Point
+G = ed.G
 
-curve = some_curves[1]
+_2G = G + G
+_3G = _2G + G
+_5G = _3G + _2G
+
+_20G = 4 * G
+_19G = _20G - G
+```
+
+In LightPHE, the [Elliptic Curve ElGamal](https://sefiks.com/2018/08/21/elliptic-curve-elgamal-encryption/) scheme is implemented, offering a secure and efficient homomorphic encryption option.
+
+```python
+forms = ["weierstass", "edwards", "koblitz"]
 
 phe = LightPHE(
     algorithm_name="EllipticCurve-ElGamal",
-    form=curve["form"],
-    curve=curve["curve"],
+    form=forms[1],
 )
 ```
 
@@ -253,7 +270,7 @@ One of the crucial factors that define the security level of an elliptic curve c
 
 Each curve in LightPHE has a specific order, which is carefully chosen to balance performance and security. By selecting an elliptic curve with a larger order, you increase the security of your cryptographic system, but this may come with a trade-off in computational efficiency. Therefore, choosing the appropriate curve order is a crucial decision based on your application’s security and performance requirements.
 
-See [`Curves`](https://github.com/serengil/LightPHE/tree/master/lightphe/elliptic_curve_forms) page for more details.
+See [`curves`](https://github.com/serengil/LightPHE/tree/master/lightphe/elliptic_curve_forms) page for a list of all supported forms, curves and their details.
 
 # Contributing
 

{lightphe-0.0.10 → lightphe-0.0.11}/lightphe/__init__.py

@@ -1,10 +1,17 @@
+# built-in dependencies
 import json
 from typing import Optional, Union, List
 
+# project dependencies
 from lightphe.models.Homomorphic import Homomorphic
 from lightphe.models.Ciphertext import Ciphertext
 from lightphe.models.Algorithm import Algorithm
 from lightphe.models.Tensor import Fraction, EncryptedTensor
+from lightphe.models.EllipticCurve import EllipticCurvePoint
+from lightphe.commons import phe_utils
+from lightphe.commons.logger import Logger
+
+# cryptosystems
 from lightphe.cryptosystems.RSA import RSA
 from lightphe.cryptosystems.ElGamal import ElGamal
 from lightphe.cryptosystems.Paillier import Paillier
@@ -14,16 +21,20 @@ from lightphe.cryptosystems.Benaloh import Benaloh
 from lightphe.cryptosystems.NaccacheStern import NaccacheStern
 from lightphe.cryptosystems.GoldwasserMicali import GoldwasserMicali
 from lightphe.cryptosystems.EllipticCurveElGamal import EllipticCurveElGamal
-from lightphe.commons import phe_utils
-from lightphe.commons.logger import Logger
+from lightphe.elliptic_curve_forms.weierstrass import Weierstrass
+from lightphe.elliptic_curve_forms.edwards import TwistedEdwards
+from lightphe.elliptic_curve_forms.koblitz import Koblitz
+
 
-# pylint: disable=eval-used, simplifiable-if-expression
+# pylint: disable=eval-used, simplifiable-if-expression, too-few-public-methods
 
 logger = Logger(module="lightphe/__init__.py")
 
+VERSION = "0.0.11"
+
 
 class LightPHE:
-    __version__ = "0.0.10"
+    __version__ = VERSION
 
     def __init__(
         self,
@@ -53,6 +64,8 @@ class LightPHE:
                  - e.g. ed25519, ed448 for edwards form
                  - e.g. secp256k1 for weierstrass form
                  - e.g. k-409 for koblitz form
+                List of all available curves:
+                    github.com/serengil/LightPHE/blob/master/lightphe/elliptic_curve_forms/README.md
                 This parameter is only used if `algorithm_name` is 'EllipticCurve-ElGamal'.
         """
         self.algorithm_name = algorithm_name
@@ -341,3 +354,44 @@ class LightPHE:
         return Ciphertext(
             algorithm_name=self.algorithm_name, keys=self.cs.keys, value=ciphertext
         )
+
+
+class ECC:
+    __version__ = VERSION
+
+    def __init__(
+        self, form_name: Optional[str] = None, curve_name: Optional[str] = None
+    ):
+        """
+        Construct an Elliptic Curve over a finite field (prime or binary)
+        Args:
+            form_name (str): specifies the form of the elliptic curve.
+                Options: 'weierstrass' (default), 'edwards', 'koblitz'.
+            curve_name (str): specifies the elliptic curve to use.
+                Options:
+                 - e.g. ed25519, ed448 for edwards form
+                 - e.g. secp256k1 for weierstrass form
+                 - e.g. k-409 for koblitz form
+                List of all available curves:
+                    github.com/serengil/LightPHE/blob/master/lightphe/elliptic_curve_forms/README.md
+        """
+        if form_name is None or form_name == "weierstrass":
+            self.curve = Weierstrass(curve=curve_name)
+        elif form_name in "edwards":
+            self.curve = TwistedEdwards(curve=curve_name)
+        elif form_name in "koblitz":
+            self.curve = Koblitz(curve=curve_name)
+        else:
+            raise ValueError(f"unimplemented curve form - {form_name}")
+
+        # base point
+        self.G = EllipticCurvePoint(self.curve.G[0], self.curve.G[1], self.curve)
+
+        # order of the curve
+        self.n = self.curve.n
+
+        # point at infinity or neutral / identity element
+        self.O = EllipticCurvePoint(self.curve.O[0], self.curve.O[1], self.curve)
+
+        # modulo
+        self.modulo = self.curve.modulo

{lightphe-0.0.10 → lightphe-0.0.11}/lightphe/cryptosystems/EllipticCurveElGamal.py

@@ -1,9 +1,10 @@
+# built-in dependencies
 import random
 from typing import Optional
+
+# project dependencies
 from lightphe.models.Homomorphic import Homomorphic
-from lightphe.elliptic_curve_forms.weierstrass import Weierstrass
-from lightphe.elliptic_curve_forms.edwards import TwistedEdwards
-from lightphe.elliptic_curve_forms.koblitz import Koblitz
+from lightphe.models.EllipticCurve import EllipticCurvePoint
 from lightphe.commons.logger import Logger
 
 logger = Logger(module="lightphe/cryptosystems/EllipticCurveElGamal.py")
@@ -39,20 +40,16 @@ class EllipticCurveElGamal(Homomorphic):
                  - secp256k1 for weierstrass form
                 This parameter is only used if `algorithm_name` is 'EllipticCurve-ElGamal'.
         """
-        if form is None or form == "weierstrass":
-            self.curve = Weierstrass(curve=curve)
-        elif form in "edwards":
-            self.curve = TwistedEdwards(curve=curve)
-        elif form in "koblitz":
-            self.curve = Koblitz(curve=curve)
-        else:
-            raise ValueError(f"unimplemented curve form - {form}")
-
-        self.keys = keys or self.generate_keys(key_size or self.curve.n.bit_length())
+        # to avoid circular import, import ECC class here
+        from lightphe import ECC
+
+        self.ecc = ECC(form_name=form, curve_name=curve)
+
+        self.keys = keys or self.generate_keys(key_size or self.ecc.n.bit_length())
         self.keys["public_key"]["form"] = form
         self.keys["private_key"]["form"] = form
-        self.plaintext_modulo = self.curve.modulo
-        self.ciphertext_modulo = self.curve.modulo
+        self.plaintext_modulo = self.ecc.modulo
+        self.ciphertext_modulo = self.ecc.modulo
 
     def generate_keys(self, key_size: int):
         """
@@ -72,8 +69,10 @@ class EllipticCurveElGamal(Homomorphic):
             f"{key_size} bit private key generated for Elliptic Curve ElGamal."
         )
 
+        # base point
+
         # public key
-        Qa = self.curve.double_and_add(G=self.curve.G, k=ka)
+        Qa = self.ecc.G * ka
 
         keys["public_key"]["Qa"] = Qa
         keys["private_key"]["ka"] = ka
@@ -87,10 +86,7 @@ class EllipticCurveElGamal(Homomorphic):
             random key (int): one time random key for encryption
         """
         # return random.getrandbits(128)
-        return random.getrandbits(
-            (isinstance(self.curve.n, int) and self.curve.n.bit_length())
-            or (isinstance(self.curve.n, str) and len(self.curve.n))
-        )
+        return random.getrandbits(self.ecc.n.bit_length())
 
     def encrypt(self, plaintext: int, random_key: Optional[int] = None) -> tuple:
         """
@@ -101,23 +97,18 @@ class EllipticCurveElGamal(Homomorphic):
         Returns
             ciphertext (tuple): c1 and c2
         """
-        # base point
-        G = self.curve.G
-
         # public key
         Qa = self.keys["public_key"]["Qa"]
 
         # random key
         r = random_key or self.generate_random_key()
 
-        s = self.curve.double_and_add(G=G, k=plaintext)
-
-        c1 = self.curve.double_and_add(G=G, k=r)
+        s = self.ecc.G * plaintext
 
-        c2 = self.curve.double_and_add(G=Qa, k=r)
-        c2 = self.curve.add_points(c2, s)
+        c1 = self.ecc.G * r
+        c2 = (Qa * r) + s
 
-        return c1, c2
+        return c1.get_point(), c2.get_point()
 
     def decrypt(self, ciphertext: tuple) -> int:
         """
@@ -130,11 +121,13 @@ class EllipticCurveElGamal(Homomorphic):
         # private key
         ka = self.keys["private_key"]["ka"]
 
+        # c1 and c2 as tuple of integers
         c1, c2 = ciphertext
 
-        c1_prime = self.curve.negative_point(c1)
-        s_prime = self.curve.double_and_add(G=c1_prime, k=ka)
-        s_prime = self.curve.add_points(P=c2, Q=s_prime)
+        c1 = EllipticCurvePoint(x=c1[0], y=c1[1], curve=self.ecc.curve)
+        c2 = EllipticCurvePoint(x=c2[0], y=c2[1], curve=self.ecc.curve)
+
+        s_prime = (-c1 * ka) + c2
 
         # s_prime is a point on the elliptic curve
         # s_prime = k x G
@@ -142,16 +135,18 @@ class EllipticCurveElGamal(Homomorphic):
         # this requires to solve ECDLP
 
         # base point
-        G = self.curve.G
+        G = self.ecc.G
         k = 2
         while True:
-            G = self.curve.add_points(P=G, Q=self.curve.G)
-            if G[0] == s_prime[0] and G[1] == s_prime[1]:
+            G = G + self.ecc.G
+
+            if G == s_prime:
                 return k
+
             k = k + 1
-            if k > self.curve.n:
+            if k > self.ecc.n:
                 raise ValueError(
-                    f"Cannot restore scalar from {s_prime} = k x {self.curve.G}"
+                    f"Cannot restore scalar from {s_prime} = k x {self.ecc.G}"
                 )
 
     def multiply(self, ciphertext1: tuple, ciphertext2: tuple) -> tuple:
@@ -169,9 +164,19 @@ class EllipticCurveElGamal(Homomorphic):
         Returns
             ciphertext (dict): Elliptic Curve ElGamal ciphertext consisting of c1 and c2 keys
         """
-        a = self.curve.add_points(P=ciphertext1[0], Q=ciphertext2[0])
-        b = self.curve.add_points(P=ciphertext1[1], Q=ciphertext2[1])
-        return a, b
+        c1_1, c1_2 = ciphertext1
+        c2_1, c2_2 = ciphertext2
+
+        # cast them to elliptic curve points
+        c1_1 = EllipticCurvePoint(x=c1_1[0], y=c1_1[1], curve=self.ecc.curve)
+        c1_2 = EllipticCurvePoint(x=c1_2[0], y=c1_2[1], curve=self.ecc.curve)
+        c2_1 = EllipticCurvePoint(x=c2_1[0], y=c2_1[1], curve=self.ecc.curve)
+        c2_2 = EllipticCurvePoint(x=c2_2[0], y=c2_2[1], curve=self.ecc.curve)
+
+        a = c1_1 + c2_1
+        b = c1_2 + c2_2
+
+        return a.get_point(), b.get_point()
 
     def xor(self, ciphertext1: tuple, ciphertext2: tuple) -> int:
         raise ValueError(
@@ -189,10 +194,17 @@ class EllipticCurveElGamal(Homomorphic):
         Returns:
             ciphertext (int): new ciphertext created with Elliptic Curve ElGamal
         """
-        return self.curve.double_and_add(
-            G=ciphertext[0],
-            k=constant,
-        ), self.curve.double_and_add(G=ciphertext[1], k=constant)
+        # Both P and Q are tuples of integers
+        P, Q = ciphertext
+
+        # cast P and Q to EllipticCurvePoint
+        P = EllipticCurvePoint(x=P[0], y=P[1], curve=self.ecc.curve)
+        Q = EllipticCurvePoint(x=Q[0], y=Q[1], curve=self.ecc.curve)
+
+        P_prime = P * constant
+        Q_prime = Q * constant
+
+        return P_prime.get_point(), Q_prime.get_point()
 
     def reencrypt(self, ciphertext: tuple) -> tuple:
         raise ValueError(

{lightphe-0.0.10 → lightphe-0.0.11}/lightphe/elliptic_curve_forms/koblitz.py

@@ -74,6 +74,9 @@ class Koblitz(EllipticCurve):
         Returns:
             result (bool): True if the point is on the curve, False otherwise
         """
+        if P == self.O:
+            return True
+
         x, y = P
 
         return bin_ops.mod(

{lightphe-0.0.10 → lightphe-0.0.11}/lightphe/elliptic_curve_forms/weierstrass.py

@@ -111,6 +111,9 @@ class Weierstrass(EllipticCurve):
         Returns
             is_on_curve (boolean): returns True if point is on the curve
         """
+        if P == self.O:
+            return True
+
         x, y = P
         return (y * y) % self.modulo == (
             pow(x, 3, self.modulo) + self.a * x + self.b

lightphe-0.0.11/lightphe/models/EllipticCurve.py

@@ -0,0 +1,160 @@
+# built-in dependencies
+from typing import Tuple
+from abc import ABC, abstractmethod
+
+# Signature for elliptic curve
+
+
+class EllipticCurve(ABC):
+    # point at infinity or neutral / identity element
+    O: Tuple[int, int]
+
+    # base point G
+    G: Tuple[int, int]
+
+    # modulo (prime p or polynomial fx)
+    modulo: int
+
+    # order of the curve
+    n: int
+
+    # coefficients
+    a: int
+    b: int = 0  # for weierstrass & koblitz form
+    d: int = 0  # for edwards form
+
+    @abstractmethod
+    def add_points(
+        self,
+        P: Tuple[int, int],
+        Q: Tuple[int, int],
+    ) -> Tuple[int, int]:
+        pass
+
+    @abstractmethod
+    def double_point(self, P: Tuple[int, int]) -> Tuple[int, int]:
+        pass
+
+    @abstractmethod
+    def is_on_curve(self, P: Tuple[int, int]) -> bool:
+        pass
+
+    @abstractmethod
+    def negative_point(self, P: Tuple[int, int]) -> Tuple[int, int]:
+        pass
+
+    def double_and_add(self, G: Tuple[int, int], k: int) -> Tuple[int, int]:
+        """
+        Perform scalar multiplication over elliptic curve
+        Args:
+            G (Tuple[int, int]): a point on an elliptic curve
+            k (int): scalar value
+        Returns
+            kxG (Tuple[int, int]): a point on an elliptic curve
+        """
+        target_point = G
+
+        if k >= self.n:
+            k = k % self.n
+        if k == 0:
+            return self.O
+        if k < 0:
+            return self.negative_point(self.double_and_add(G, abs(k)))
+
+        k_binary = bin(k)[2:]
+
+        for i in range(1, len(k_binary)):
+            current_bit = k_binary[i : i + 1]
+
+            # doubling - always
+            target_point = self.double_point(target_point)
+
+            if current_bit == "1":
+                target_point = self.add_points(target_point, G)
+
+        assert (
+            self.is_on_curve(target_point) is True
+        ), f"{target_point} is not on the curve!"
+
+        return target_point
+
+
+class EllipticCurvePoint:
+    """
+    Define a point on an elliptic curve
+    """
+
+    def __init__(self, x: int, y: int, curve: EllipticCurve):
+        self.x = x
+        self.y = y
+        self.curve = curve
+
+        assert self.curve.is_on_curve((x, y)), f"({x}, {y}) is not on the curve!"
+
+    def get_point(self) -> Tuple[int, int]:
+        return (self.x, self.y)
+
+    def __repr__(self):
+
+        if (
+            self.x == self.curve.O[0]
+            and self.y == self.curve.O[1]
+            and self.x == float("inf")
+            and self.y == float("inf")
+        ):
+            # because Edwards has neutral / identity element instead of point at infinity
+            return "\U0001D4AA"  # unicode for "𝒪" (circle O)
+        return f"({self.x}, {self.y})"
+
+    def __str__(self):
+        return self.__repr__()
+
+    def __add__(self, other: "EllipticCurvePoint") -> "EllipticCurvePoint":
+        """
+        Calculate P + Q for two given points P and Q
+        """
+        if not isinstance(other, EllipticCurvePoint):
+            raise ValueError("Addition is only defined for 2 points")
+
+        if self.curve != other.curve:
+            raise ValueError("Points are not on the same curve")
+
+        x, y = self.curve.add_points((self.x, self.y), (other.x, other.y))
+        return EllipticCurvePoint(x, y, self.curve)
+
+    def __sub__(self, other: "EllipticCurvePoint") -> "EllipticCurvePoint":
+        """
+        Calculate P - Q for two given points P and Q
+        """
+        return self.__add__(other=other.__neg__())
+
+    def __mul__(self, k: int) -> "EllipticCurvePoint":
+        """
+        Calculate k*P for a given k and P
+        """
+        if not isinstance(k, int):
+            raise ValueError("Multiplication is only defined for an integer")
+
+        x, y = self.curve.double_and_add((self.x, self.y), k)
+        return EllipticCurvePoint(x, y, self.curve)
+
+    def __rmul__(self, k: int) -> "EllipticCurvePoint":
+        """
+        Calculate k*P for a given k and P
+        """
+        if not isinstance(k, int):
+            raise ValueError("Multiplication is only defined for an integer")
+        return self.__mul__(k)
+
+    def __neg__(self) -> "EllipticCurvePoint":
+        """
+        Calculate -P for a given P
+        """
+        x, y = self.curve.negative_point((self.x, self.y))
+        return EllipticCurvePoint(x, y, self.curve)
+
+    def __eq__(self, other: "EllipticCurvePoint") -> bool:
+        """
+        Check if two points are equal
+        """
+        return self.x == other.x and self.y == other.y and self.curve == other.curve

{lightphe-0.0.10 → lightphe-0.0.11}/lightphe.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: lightphe
-Version: 0.0.10
+Version: 0.0.11
 Summary: A Lightweight Partially Homomorphic Encryption Library for Python
 Home-page: https://github.com/serengil/LightPHE
 Author: Sefik Ilkin Serengil
@@ -22,7 +22,8 @@ License-File: LICENSE
 [![Stars](https://img.shields.io/github/stars/serengil/LightPHE?color=yellow&style=flat&label=%E2%AD%90%20stars)](https://github.com/serengil/LightPHE/stargazers)
 [![Tests](https://github.com/serengil/LightPHE/actions/workflows/tests.yml/badge.svg)](https://github.com/serengil/LightPHE/actions/workflows/tests.yml)
 [![License](http://img.shields.io/:license-MIT-green.svg?style=flat)](https://github.com/serengil/LightPHE/blob/master/LICENSE)
-[![DOI](http://img.shields.io/:DOI-10.48550/arXiv.2408.05219-blue.svg?style=flat)](https://arxiv.org/abs/2408.05219)
+[![arXiv](https://img.shields.io/badge/arXiv-2408.05219-b31b1b.svg?logo=arXiv)](https://arxiv.org/abs/2408.05219)
+<!-- [![DOI](http://img.shields.io/:DOI-10.48550/arXiv.2408.05219-blue.svg?style=flat)](https://arxiv.org/abs/2408.05219) -->
 
 [![Blog](https://img.shields.io/:blog-sefiks.com-blue.svg?style=flat&logo=wordpress)](https://sefiks.com)
 [![YouTube](https://img.shields.io/:youtube-@sefiks-red.svg?style=flat&logo=youtube)](https://www.youtube.com/@sefiks?sub_confirmation=1)
@@ -245,23 +246,39 @@ with pytest.raises(ValueError, match="Paillier is not homomorphic with respect t
 
 However, if you tried to multiply ciphertexts with RSA, or xor ciphertexts with Goldwasser-Micali, these will be succeeded because those cryptosystems support those homomorphic operations.
 
-### Elliptic Curve Cryptography
+### Elliptic Curve Cryptography
 
-ECC is a powerful public-key cryptosystem based on the algebraic structure of elliptic curves over finite fields. In LightPHE, the [Elliptic Curve ElGamal](https://sefiks.com/2018/08/21/elliptic-curve-elgamal-encryption/) scheme is implemented, offering a secure and efficient homomorphic encryption option. The library supports 100+ standard elliptic curves.
+ECC is a powerful public-key cryptosystem based on the algebraic structure of elliptic curves over finite fields. The library supports 3 elliptic curve forms (weierstrass, edwards and koblitz) and 100+ standard elliptic curve configurations.
+
+Building an elliptic curve with LightPHE is very straightforward. Once the curve is initialized, you can perform operations such as point addition and scalar multiplication.
 
 ```python
-some_curves = [
-    {"form": "weierstrass", "curve": "secp256k1"},
-    {"form": "edwards", "curve": "ed25519"},
-    {"form": "koblitz", "curve": "k163"}
-]
+from lightphe import ECC
+
+forms = ["weierstrass", "edwards", "koblitz"]
+
+# construct an elliptic curve
+ed = ECC(form_name="edwards")
+
+# Base Point
+G = ed.G
 
-curve = some_curves[1]
+_2G = G + G
+_3G = _2G + G
+_5G = _3G + _2G
+
+_20G = 4 * G
+_19G = _20G - G
+```
+
+In LightPHE, the [Elliptic Curve ElGamal](https://sefiks.com/2018/08/21/elliptic-curve-elgamal-encryption/) scheme is implemented, offering a secure and efficient homomorphic encryption option.
+
+```python
+forms = ["weierstass", "edwards", "koblitz"]
 
 phe = LightPHE(
     algorithm_name="EllipticCurve-ElGamal",
-    form=curve["form"],
-    curve=curve["curve"],
+    form=forms[1],
 )
 ```
 
@@ -269,7 +286,7 @@ One of the crucial factors that define the security level of an elliptic curve c
 
 Each curve in LightPHE has a specific order, which is carefully chosen to balance performance and security. By selecting an elliptic curve with a larger order, you increase the security of your cryptographic system, but this may come with a trade-off in computational efficiency. Therefore, choosing the appropriate curve order is a crucial decision based on your application’s security and performance requirements.
 
-See [`Curves`](https://github.com/serengil/LightPHE/tree/master/lightphe/elliptic_curve_forms) page for more details.
+See [`curves`](https://github.com/serengil/LightPHE/tree/master/lightphe/elliptic_curve_forms) page for a list of all supported forms, curves and their details.
 
 # Contributing
 

{lightphe-0.0.10 → lightphe-0.0.11}/lightphe.egg-info/SOURCES.txt

@@ -38,6 +38,7 @@ tests/test_benaloh.py
 tests/test_cloud.py
 tests/test_damgard.py
 tests/test_elgamal.py
+tests/test_ellipticcurve.py
 tests/test_ellipticcurveelgamal.py
 tests/test_exporting_keys.py
 tests/test_goldwasser.py

{lightphe-0.0.10 → lightphe-0.0.11}/setup.py

@@ -8,7 +8,7 @@ with open("requirements.txt", "r", encoding="utf-8") as f:
 
 setuptools.setup(
     name="lightphe",
-    version="0.0.10",
+    version="0.0.11",
     author="Sefik Ilkin Serengil",
     author_email="serengil@gmail.com",
     description="A Lightweight Partially Homomorphic Encryption Library for Python",

lightphe-0.0.11/tests/test_ellipticcurve.py

@@ -0,0 +1,75 @@
+# project dependencies
+import pytest
+
+# project dependencies
+from lightphe import ECC
+from lightphe.commons.logger import Logger
+
+logger = Logger(module="tests/test_ellipticcurve.py")
+
+
+def test_elliptic_curve_interface():
+    forms = ["weierstrass", "edwards", "koblitz"]
+    for form in forms:
+        # construct an elliptic curve for the given form
+        ec = ECC(form_name=form, curve_name="test-curve")
+
+        # base point
+        G = ec.G
+
+        # order of the curve
+        n = ec.n
+
+        for i in range(1, n):
+            k = i + 1
+            operations = ["G"]
+            cumulative_point = G
+            for _ in range(0, i):
+                cumulative_point = cumulative_point + G
+                operations.append("G")
+
+            kG = k * G
+            Gk = G * k
+
+            assert kG == Gk
+            assert kG == cumulative_point
+
+            logger.debug(f"{'+'.join(operations)} = {cumulative_point}")
+            logger.debug(f"""{k} x G = {kG}""")
+            logger.debug(f"""G x {k} = {Gk}""")
+            logger.debug("--------")
+
+        minus_G = -G
+        assert ec.curve.negative_point(P=(G.x, G.y)) == (minus_G.x, minus_G.y)
+
+        _3G = 3 * G
+        _5G = 5 * G
+        minus_5G = -5 * G
+        assert ec.curve.negative_point(P=(_5G.x, _5G.y)) == (minus_5G.x, minus_5G.y)
+
+        _5G_minus_G = _5G - G
+        logger.debug(f"""5G - G = {_5G_minus_G}""")
+
+        _3G_plus_G = _3G + G
+        logger.debug(f"""3G + G = {_3G_plus_G}""")
+
+        assert _3G_plus_G == _5G_minus_G
+
+        # multiplication cannot be done for 2 points
+        with pytest.raises(
+            ValueError, match="Multiplication is only defined for an integer"
+        ):
+            _ = _5G * G
+
+        with pytest.raises(ValueError, match="Addition is only defined for 2 points"):
+            _ = _5G + 5
+
+        logger.info(f"✅ Test elliptic curve interface for {form} form done.")
+
+
+def test_addition_of_2_points_of_different_curves():
+    ws = ECC(form_name="weierstrass", curve_name="test-curve")
+    ed = ECC(form_name="edwards", curve_name="test-curve")
+
+    with pytest.raises(ValueError, match="Points are not on the same curve"):
+        _ = ws.G + ed.G

{lightphe-0.0.10 → lightphe-0.0.11}/tests/test_ellipticcurveelgamal.py

@@ -23,8 +23,10 @@ def __test_build_curves():
         for curve in curves:
             cs = EllipticCurveElGamal(form=form, curve=curve)
             field = "binary" if form == "koblitz" else "prime"
-            logger.info(f"| {form} | {curve} | {field} | {cs.curve.n.bit_length()} |")
-            summary.append((form, curve, field, cs.curve.n.bit_length()))
+            logger.info(
+                f"| {form} | {curve} | {field} | {cs.ecc.curve.n.bit_length()} |"
+            )
+            summary.append((form, curve, field, cs.ecc.curve.n.bit_length()))
 
     import pandas as pd
 
@@ -43,6 +45,9 @@ def __test_elliptic_curve_elgamal():
         curves = inventory.list_curves(form)
         for curve in curves:
 
+            if curve in ["test-curve"]:
+                continue
+
             logger.debug(
                 f"ℹ️ Elliptic Curve ElGamal test is running for EC form {form}&{curve}"
             )
@@ -89,7 +94,7 @@ def __test_elliptic_curve_elgamal():
 
             logger.info(
                 f"✅ Elliptic Curve ElGamal test succeeded for EC form {form}&{curve}"
-                f" ({cs.curve.n.bit_length()}-bit) in {duration} seconds"
+                f" ({cs.ecc.curve.n.bit_length()}-bit) in {duration} seconds"
             )
 
 
@@ -132,9 +137,9 @@ def test_api():
 def test_adding_a_point_with_its_negative():
     for form in FORMS:
         cs = EllipticCurveElGamal(form=form)
-        G = cs.curve.G
-        G_minus = cs.curve.negative_point(G)
-        assert cs.curve.O == cs.curve.add_points(G, G_minus)
+        G = cs.ecc.curve.G
+        G_minus = cs.ecc.curve.negative_point(G)
+        assert cs.ecc.curve.O == cs.ecc.curve.add_points(G, G_minus)
 
         logger.info(f"✅ Adding a point with its negative tested for {form}")
 
@@ -142,57 +147,103 @@ def test_adding_a_point_with_its_negative():
 def test_zero_times_base_point():
     for form in FORMS:
         cs = EllipticCurveElGamal(form=form)
-        G = cs.curve.G
-        assert cs.curve.double_and_add(G, 0) == cs.curve.O
+        G = cs.ecc.curve.G
+        assert cs.ecc.curve.double_and_add(G, 0) == cs.ecc.curve.O
         logger.info(f"✅ Test 0 x G = O done for {form}")
 
 
 def test_double_and_add_with_negative_input():
     for form in FORMS:
         cs = EllipticCurveElGamal(form=form)
-        G = cs.curve.G
-        assert cs.curve.double_and_add(G, -10) == cs.curve.negative_point(
-            cs.curve.double_and_add(G, 10)
+        G = cs.ecc.curve.G
+        assert cs.ecc.curve.double_and_add(G, -10) == cs.ecc.curve.negative_point(
+            cs.ecc.curve.double_and_add(G, 10)
         )
         logger.info(f"✅ Test (-10) x G = -(10 x G) done for {form}")
 
 
 def test_elliptic_curve_cyclic_group_on_test_curve():
-    cs = EllipticCurveElGamal(form="weierstrass", curve="test-curve-pf-23")
 
-    for k in range(0, 5 * cs.curve.n):
-        P = cs.curve.double_and_add(cs.curve.G, k)
-        logger.debug(f"{k} x G = {P}")
+    curves = ["weierstrass", "koblitz", "edwards"]
+
+    for form in curves:
+        logger.debug(f"ℹ️ Testing elliptic curve cyclic group on {form} test curve")
+        cs = EllipticCurveElGamal(form=form, curve="test-curve")
+
+        for k in range(0, 2 * cs.ecc.curve.n + 1):
+            P = cs.ecc.curve.double_and_add(cs.ecc.curve.G, k)
+            logger.debug(f"{k} x G = {P}")
 
-        if k in [0, cs.curve.n]:
-            assert P == cs.curve.O
+            if k in [0, cs.ecc.curve.n]:
+                assert P == cs.ecc.curve.O
 
-    logger.info("✅ Test elliptic curve cyclic group on test curve done.")
+        logger.info(f"✅ Test elliptic curve cyclic group on test {form} curve done.")
 
 
-def test_point_addition_returning_point_at_infinity():
-    cs = EllipticCurveElGamal(form="weierstrass", curve="test-curve-pf-23")
+def test_weierstrass_point_addition_returning_point_at_infinity():
+    cs = EllipticCurveElGamal(form="weierstrass", curve="test-curve")
 
-    # we know that 20G + 8 G = 28G = point at infinity
-    P = cs.curve.add_points(
-        cs.curve.double_and_add(cs.curve.G, 20), cs.curve.double_and_add(cs.curve.G, 8)
+    # we know that 20G + 8G = 28G = point at infinity
+    P = cs.ecc.curve.add_points(
+        cs.ecc.curve.double_and_add(cs.ecc.curve.G, 20),
+        cs.ecc.curve.double_and_add(cs.ecc.curve.G, 8),
     )
-    assert P == cs.curve.O
+    assert P == cs.ecc.curve.O
 
-    _14G = cs.curve.double_and_add(cs.curve.G, 14)
-    Q = cs.curve.add_points(_14G, _14G)
-    assert Q == cs.curve.O
+    _14G = cs.ecc.curve.double_and_add(cs.ecc.curve.G, 14)
+    Q = cs.ecc.curve.add_points(_14G, _14G)
+    assert Q == cs.ecc.curve.O
+
+    logger.info("✅ Test weierstras point addition returning point at infinity done.")
+
+
+def test_koblitz_point_addition_returning_point_at_infinity():
+    cs = EllipticCurveElGamal(form="koblitz", curve="test-curve")
+
+    # we know that 12G + 4G = 16G = point at infinity
+    P = cs.ecc.curve.add_points(
+        cs.ecc.curve.double_and_add(cs.ecc.curve.G, 12),
+        cs.ecc.curve.double_and_add(cs.ecc.curve.G, 4),
+    )
+    assert P == cs.ecc.curve.O
 
-    logger.info("✅ Test elliptic curve cyclic group on test curve done.")
+    _8G = cs.ecc.curve.double_and_add(cs.ecc.curve.G, 8)
+    Q = cs.ecc.curve.add_points(_8G, _8G)
+    assert Q == cs.ecc.curve.O
+
+    logger.info("✅ Test koblitz point addition returning point at infinity done.")
+
+
+def test_edwards_point_addition_returning_point_at_infinity():
+    cs = EllipticCurveElGamal(form="edwards", curve="test-curve")
+
+    # we know that 6G + 2G = 8G = point at infinity
+    P = cs.ecc.curve.add_points(
+        cs.ecc.curve.double_and_add(cs.ecc.curve.G, 6),
+        cs.ecc.curve.double_and_add(cs.ecc.curve.G, 2),
+    )
+    assert P == cs.ecc.curve.O
+
+    _4G = cs.ecc.curve.double_and_add(cs.ecc.curve.G, 4)
+    Q = cs.ecc.curve.add_points(_4G, _4G)
+    assert Q == cs.ecc.curve.O
+
+    logger.info("✅ Test edwards point addition returning point at infinity done.")
 
 
 def test_double_and_add_for_k_close_to_n():
     for form in FORMS:
         cs = EllipticCurveElGamal(form=form)
 
-        _ = cs.curve.double_and_add(cs.curve.G, cs.curve.n - 1)
-        assert cs.curve.double_and_add(cs.curve.G, cs.curve.n) == cs.curve.O
-        assert cs.curve.double_and_add(cs.curve.G, cs.curve.n + 1) == cs.curve.G
+        _ = cs.ecc.curve.double_and_add(cs.ecc.curve.G, cs.ecc.curve.n - 1)
+        assert (
+            cs.ecc.curve.double_and_add(cs.ecc.curve.G, cs.ecc.curve.n)
+            == cs.ecc.curve.O
+        )
+        assert (
+            cs.ecc.curve.double_and_add(cs.ecc.curve.G, cs.ecc.curve.n + 1)
+            == cs.ecc.curve.G
+        )
 
         logger.info(
             f"✅ Double and add for k being close to order test done for {form}"
@@ -203,10 +254,10 @@ def test_add_neutral_point():
     for form in FORMS:
         cs = EllipticCurveElGamal(form=form)
 
-        _7G = cs.curve.double_and_add(cs.curve.G, 7)
+        _7G = cs.ecc.curve.double_and_add(cs.ecc.curve.G, 7)
 
-        assert cs.curve.add_points(_7G, cs.curve.O) == _7G
-        assert cs.curve.add_points(cs.curve.O, _7G) == _7G
-        assert cs.curve.add_points(cs.curve.O, cs.curve.O) == cs.curve.O
+        assert cs.ecc.curve.add_points(_7G, cs.ecc.curve.O) == _7G
+        assert cs.ecc.curve.add_points(cs.ecc.curve.O, _7G) == _7G
+        assert cs.ecc.curve.add_points(cs.ecc.curve.O, cs.ecc.curve.O) == cs.ecc.curve.O
 
         logger.info(f"✅ Adding neutral point test done for {form}")

lightphe-0.0.10/lightphe/models/EllipticCurve.py

@@ -1,78 +0,0 @@
-from typing import Tuple
-from abc import ABC, abstractmethod
-
-# Signature for elliptic curve
-
-
-class EllipticCurve(ABC):
-    # point at infinity or neutral / identity element
-    O: Tuple[int, int]
-
-    # base point G
-    G: Tuple[int, int]
-
-    # modulo (prime p or polynomial fx)
-    modulo: int
-
-    # order of the curve
-    n: int
-
-    # coefficients
-    a: int
-    b: int = 0  # for weierstrass & koblitz form
-    d: int = 0  # for edwards form
-
-    @abstractmethod
-    def add_points(
-        self,
-        P: Tuple[int, int],
-        Q: Tuple[int, int],
-    ) -> Tuple[int, int]:
-        pass
-
-    @abstractmethod
-    def double_point(self, P: Tuple[int, int]) -> Tuple[int, int]:
-        pass
-
-    @abstractmethod
-    def is_on_curve(self, P: Tuple[int, int]) -> bool:
-        pass
-
-    @abstractmethod
-    def negative_point(self, P: Tuple[int, int]) -> Tuple[int, int]:
-        pass
-
-    def double_and_add(self, G: Tuple[int, int], k: int) -> Tuple[int, int]:
-        """
-        Perform scalar multiplication over elliptic curve
-        Args:
-            G (Tuple[int, int]): a point on an elliptic curve
-            k (int): scalar value
-        Returns
-            kxG (Tuple[int, int]): a point on an elliptic curve
-        """
-        target_point = G
-
-        if k >= self.n:
-            k = k % self.n
-        if k == 0:
-            return self.O
-        if k < 0:
-            return self.negative_point(self.double_and_add(G, abs(k)))
-
-        k_binary = bin(k)[2:]
-
-        for i in range(1, len(k_binary)):
-            current_bit = k_binary[i : i + 1]
-
-            # doubling - always
-            target_point = self.double_point(target_point)
-
-            if current_bit == "1":
-                target_point = self.add_points(target_point, G)
-
-        assert (
-            self.is_on_curve(target_point) is True
-        ), f"{target_point} is not on the curve!"
-
-        return target_point