lightphe 0.0.10__tar.gz → 0.0.12__tar.gz

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: lightphe
-Version: 0.0.10
+Version: 0.0.12
 Summary: A Lightweight Partially Homomorphic Encryption Library for Python
 Home-page: https://github.com/serengil/LightPHE
 Author: Sefik Ilkin Serengil
@@ -22,7 +22,9 @@ 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)
+[![Hacker News](https://img.shields.io/badge/dynamic/json?color=orange&label=Hacker%20News&query=score&url=https%3A%2F%2Fhacker-news.firebaseio.com%2Fv0%2Fitem%2F43024283.json&logo=y-combinator)](https://news.ycombinator.com/item?id=43024283)
+<!-- [![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 +247,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 * _5G
+_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 +287,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.12}/README.md

@@ -6,7 +6,9 @@
 [![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)
+[![Hacker News](https://img.shields.io/badge/dynamic/json?color=orange&label=Hacker%20News&query=score&url=https%3A%2F%2Fhacker-news.firebaseio.com%2Fv0%2Fitem%2F43024283.json&logo=y-combinator)](https://news.ycombinator.com/item?id=43024283)
+<!-- [![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 +231,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 * _5G
+_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 +271,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.12}/lightphe/__init__.py

@@ -1,10 +1,23 @@
+# built-in dependencies
+import time
 import json
 from typing import Optional, Union, List
+import multiprocessing
+from contextlib import closing
 
+# 3rd party dependencies
+from tqdm import tqdm
+
+# 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 +27,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.12"
+
 
 class LightPHE:
-    __version__ = "0.0.10"
+    __version__ = VERSION
 
     def __init__(
         self,
@@ -53,6 +70,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
@@ -196,46 +215,49 @@ class LightPHE:
             encrypted tensor (list of encrypted tensor object)
         """
         encrypted_tensor: List[Fraction] = []
-        for m in tensor:
-            if isinstance(m, int):
-                dividend_encrypted = self.cs.encrypt(
-                    plaintext=(m % self.cs.plaintext_modulo) * pow(10, self.precision)
-                )
-                abs_dividend_encrypted = self.cs.encrypt(
-                    plaintext=(abs(m) % self.cs.plaintext_modulo)
-                    * pow(10, self.precision)
-                )
-                divisor_encrypted = self.cs.encrypt(plaintext=pow(10, self.precision))
-                c = Fraction(
-                    dividend=dividend_encrypted,
-                    divisor=divisor_encrypted,
-                    abs_dividend=abs_dividend_encrypted,
-                    sign=1 if m >= 0 else -1,
-                )
-            elif isinstance(m, float):
-                dividend, divisor = phe_utils.fractionize(
-                    value=(m % self.cs.plaintext_modulo),
-                    modulo=self.cs.plaintext_modulo,
-                    precision=self.precision,
-                )
-                abs_dividend, _ = phe_utils.fractionize(
-                    value=(abs(m) % self.cs.plaintext_modulo),
-                    modulo=self.cs.plaintext_modulo,
-                    precision=self.precision,
-                )
-                dividend_encrypted = self.cs.encrypt(plaintext=dividend)
-                abs_dividend_encrypted = self.cs.encrypt(plaintext=abs_dividend)
-                divisor_encrypted = self.cs.encrypt(plaintext=divisor)
-                c = Fraction(
-                    dividend=dividend_encrypted,
-                    divisor=divisor_encrypted,
-                    abs_dividend=abs_dividend_encrypted,
-                    sign=1 if m >= 0 else -1,
+
+        encrypted_zero = self.cs.encrypt(plaintext=0)
+        divisor_encrypted = self.cs.encrypt(plaintext=10**self.precision)
+        is_positive_tensor = all(m >= 0 for m in tensor)
+
+        num_workers = min(len(tensor), 2 * multiprocessing.cpu_count())
+        logger.debug(f"encrypting tensors in {num_workers} parallel")
+
+        with closing(multiprocessing.Pool(num_workers)) as pool:
+            funclist = []
+
+            for m in tensor:
+                f = pool.apply_async(
+                    encrypt_something,
+                    (
+                        m,
+                        divisor_encrypted,
+                        self.cs,
+                        self.precision,
+                        encrypted_zero,
+                        is_positive_tensor,
+                    ),
                 )
-            else:
-                raise ValueError(f"unimplemented type - {type(m)}")
-            encrypted_tensor.append(c)
-        return EncryptedTensor(fractions=encrypted_tensor, cs=self.cs)
+                funclist.append(f)
+
+            tic = time.time()
+            encrypted_tensor = []
+            for f in tqdm(
+                funclist,
+                desc="Encrypting tensors",
+                disable=True if len(tensor) < 100 else False,
+            ):
+                result = f.get(timeout=10)
+                encrypted_tensor.append(result)
+
+            toc = time.time()
+            logger.debug(f"encryption took {toc - tic} seconds")
+
+            return EncryptedTensor(
+                fractions=encrypted_tensor,
+                cs=self.cs,
+                precision=self.precision,
+            )
 
     def __decrypt_tensors(
         self, encrypted_tensor: EncryptedTensor
@@ -341,3 +363,112 @@ class LightPHE:
         return Ciphertext(
             algorithm_name=self.algorithm_name, keys=self.cs.keys, value=ciphertext
         )
+
+
+def encrypt_something(
+    m: Union[int, float],
+    divisor_encrypted,
+    cs: Homomorphic,
+    precision: int,
+    encrypted_zero: int,
+    is_positive_tensor: bool,
+) -> Fraction:
+    if m == 0:
+        # this is very common in VGG-Face embeddings
+        c = Fraction(
+            dividend=encrypted_zero,
+            divisor=divisor_encrypted,
+            abs_dividend=encrypted_zero,
+            sign=0,
+        )
+    elif isinstance(m, int):
+        dividend_encrypted = cs.encrypt(
+            plaintext=(m % cs.plaintext_modulo) * pow(10, precision)
+        )
+        abs_dividend_encrypted = (
+            dividend_encrypted
+            if is_positive_tensor
+            else cs.encrypt(
+                plaintext=(abs(m) % cs.plaintext_modulo) * pow(10, precision)
+            )
+        )
+        # divisor_encrypted = self.cs.encrypt(plaintext=pow(10, self.precision))
+        c = Fraction(
+            dividend=dividend_encrypted,
+            divisor=divisor_encrypted,
+            abs_dividend=abs_dividend_encrypted,
+            sign=1 if m >= 0 else -1,
+        )
+    elif isinstance(m, float):
+        dividend, _ = phe_utils.fractionize(
+            value=(m % cs.plaintext_modulo),
+            modulo=cs.plaintext_modulo,
+            precision=precision,
+        )
+        abs_dividend = (
+            dividend
+            if is_positive_tensor
+            else phe_utils.fractionize(
+                value=(abs(m) % cs.plaintext_modulo),
+                modulo=cs.plaintext_modulo,
+                precision=precision,
+            )[0]
+        )
+        dividend_encrypted = cs.encrypt(plaintext=dividend)
+        abs_dividend_encrypted = (
+            dividend_encrypted
+            if is_positive_tensor
+            else cs.encrypt(plaintext=abs_dividend)
+        )
+        # divisor_encrypted = self.cs.encrypt(plaintext=_divisor)
+        c = Fraction(
+            dividend=dividend_encrypted,
+            divisor=divisor_encrypted,
+            abs_dividend=abs_dividend_encrypted,
+            sign=1 if m >= 0 else -1,
+        )
+    else:
+        raise ValueError(f"unimplemented type - {type(m)}")
+
+    return c
+
+
+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.12}/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())
-        self.keys["public_key"]["form"] = form
-        self.keys["private_key"]["form"] = form
-        self.plaintext_modulo = self.curve.modulo
-        self.ciphertext_modulo = self.curve.modulo
+        # 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["curve"] = curve
+        self.keys["form"] = form
+        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.12}/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.12}/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