lightphe 0.0.19__tar.gz → 0.0.21__tar.gz

{lightphe-0.0.19 → lightphe-0.0.21}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: lightphe
-Version: 0.0.19
+Version: 0.0.21
 Summary: A Lightweight Partially Homomorphic Encryption Library for Python
 Home-page: https://github.com/serengil/LightPHE
 Author: Sefik Ilkin Serengil
@@ -36,7 +36,7 @@ License-File: LICENSE
 
 <p align="center"><img src="https://raw.githubusercontent.com/serengil/LightPHE/master/icons/phi.png" width="200" height="240"></p>
 
-LightPHE is a lightweight partially homomorphic encryption library for python. It is a hybrid homomoprhic encryption library wrapping many schemes such as [`RSA`](https://sefiks.com/2023/03/06/a-step-by-step-partially-homomorphic-encryption-example-with-rsa-in-python/), [`ElGamal`](https://sefiks.com/2023/03/27/a-step-by-step-partially-homomorphic-encryption-example-with-elgamal-in-python/), [`Exponential ElGamal`](https://sefiks.com/2023/03/27/a-step-by-step-partially-homomorphic-encryption-example-with-elgamal-in-python/), [`Elliptic Curve ElGamal`](https://sefiks.com/2018/08/21/elliptic-curve-elgamal-encryption/) ([`Weierstrass`](https://sefiks.com/2016/03/13/the-math-behind-elliptic-curve-cryptography/), [`Koblitz`](sefiks.com/2016/03/13/the-math-behind-elliptic-curves-over-binary-field/) and [`Edwards`](https://sefiks.com/2018/12/19/a-gentle-introduction-to-edwards-curves/) forms), [`Paillier`](https://sefiks.com/2023/04/03/a-step-by-step-partially-homomorphic-encryption-example-with-paillier-in-python/), [`Damgard-Jurik`](https://sefiks.com/2023/10/20/a-step-by-step-partially-homomorphic-encryption-example-with-damgard-jurik-in-python/), [`Okamoto–Uchiyama`](https://sefiks.com/2023/10/20/a-step-by-step-partially-homomorphic-encryption-example-with-okamoto-uchiyama-in-python/), [`Benaloh`](https://sefiks.com/2023/10/06/a-step-by-step-partially-homomorphic-encryption-example-with-benaloh-in-python-from-scratch/), [`Naccache–Stern`](https://sefiks.com/2023/10/26/a-step-by-step-partially-homomorphic-encryption-example-with-naccache-stern-in-python/), [`Goldwasser–Micali`](https://sefiks.com/2023/10/27/a-step-by-step-partially-homomorphic-encryption-example-with-goldwasser-micali-in-python/).
+LightPHE is a lightweight partially homomorphic encryption library for python. It is a hybrid homomoprhic encryption library wrapping many schemes such as [`RSA`](https://sefiks.com/2023/03/06/a-step-by-step-partially-homomorphic-encryption-example-with-rsa-in-python/), [`ElGamal`](https://sefiks.com/2023/03/27/a-step-by-step-partially-homomorphic-encryption-example-with-elgamal-in-python/), [`Exponential ElGamal`](https://sefiks.com/2023/03/27/a-step-by-step-partially-homomorphic-encryption-example-with-elgamal-in-python/), [`Elliptic Curve ElGamal`](https://sefiks.com/2018/08/21/elliptic-curve-elgamal-encryption/) ([`Weierstrass`](https://sefiks.com/2016/03/13/the-math-behind-elliptic-curve-cryptography/), [`Koblitz`](sefiks.com/2016/03/13/the-math-behind-elliptic-curves-over-binary-field/) and [`Edwards`](https://sefiks.com/2018/12/19/a-gentle-introduction-to-edwards-curves/) forms), [`Paillier`](https://sefiks.com/2023/04/03/a-step-by-step-partially-homomorphic-encryption-example-with-paillier-in-python/), [`Damgard-Jurik`](https://sefiks.com/2023/10/20/a-step-by-step-partially-homomorphic-encryption-example-with-damgard-jurik-in-python/), [`Okamoto–Uchiyama`](https://sefiks.com/2023/10/20/a-step-by-step-partially-homomorphic-encryption-example-with-okamoto-uchiyama-in-python/), [`Benaloh`](https://sefiks.com/2023/10/06/a-step-by-step-partially-homomorphic-encryption-example-with-benaloh-in-python-from-scratch/), [`Naccache–Stern`](https://sefiks.com/2023/10/26/a-step-by-step-partially-homomorphic-encryption-example-with-naccache-stern-in-python/), [`Goldwasser–Micali`](https://sefiks.com/2023/10/27/a-step-by-step-partially-homomorphic-encryption-example-with-goldwasser-micali-in-python/), `Sander-Young-Yung`, `Boneh-Goh-Nissim`.
 
 # Partially vs Fully Homomorphic Encryption
 
@@ -67,18 +67,20 @@ from lightphe import LightPHE
 
 In summary, LightPHE is covering following algorithms and these are partially homomorphic with respect to the operations mentioned in the following table.
 
-| Algorithm | Multiplicatively<br>Homomorphic | Additively<br>Homomorphic | Scalar Multiplication | Exclusively<br>Homomorphic | Regeneration<br>of Ciphertext |
-| --- | --- | --- | --- | --- | --- |
-| RSA | ✅ | ❌ | ❌ | ❌ | ❌ |
-| ElGamal | ✅ | ❌ | ❌ | ❌ | ✅ |
-| Exponential ElGamal | ❌ | ✅ | ✅ | ❌ | ✅ |
-| Elliptic Curve ElGamal | ❌ | ✅ | ✅ | ❌ | ❌ |
-| Paillier | ❌ | ✅ | ✅ | ❌ | ✅ |
-| Damgard-Jurik | ❌ | ✅ | ✅ | ❌ | ✅ |
-| Benaloh | ❌ | ✅ | ✅ | ❌ | ✅ |
-| Naccache-Stern | ❌ | ✅ | ✅ | ❌ | ✅ |
-| Okamoto-Uchiyama | ❌ | ✅ | ✅ | ❌ | ✅ |
-| Goldwasser-Micali | ❌ | ❌ | ❌ | ✅ | ❌ |
+| Algorithm | Multiplicatively<br>Homomorphic | Additively<br>Homomorphic | Scalar Multiplication | Bitwise-XOR Homomorphic | Bitwise-AND Homomorphic | Regeneration<br>of Ciphertext |
+| --- | --- | --- | --- | --- | --- | --- |
+| RSA | ✅ | ❌ | ❌ | ❌ | ❌ | ❌ |
+| ElGamal | ✅ | ❌ | ❌ | ❌ | ❌ | ✅ |
+| Exponential ElGamal | ❌ | ✅ | ✅ | ❌ | ❌ | ✅ |
+| Elliptic Curve ElGamal | ❌ | ✅ | ✅ | ❌ | ❌ | ✅ |
+| Paillier | ❌ | ✅ | ✅ | ❌ | ❌ | ✅ |
+| Damgard-Jurik | ❌ | ✅ | ✅ | ❌ | ❌ | ✅ |
+| Benaloh | ❌ | ✅ | ✅ | ❌ | ❌ | ✅ |
+| Naccache-Stern | ❌ | ✅ | ✅ | ❌ | ❌ | ✅ |
+| Okamoto-Uchiyama | ❌ | ✅ | ✅ | ❌ | ❌ | ✅ |
+| Goldwasser-Micali | ❌ | ❌ | ❌ | ✅ | ❌ | ✅  |
+| Sander-Young-Yung | ❌ | ❌ | ❌ | ❌ | ✅ | ✅ |
+| Boneh-Goh-Nissim | 1️⃣ | ✅ | ✅ | ❌ | ❌ | ✅ |
 
 # Building cryptosystem
 
@@ -95,7 +97,9 @@ algorithms = [
   "Benaloh",
   "Naccache-Stern",
   "Goldwasser-Micali",
-  "EllipticCurve-ElGamal"
+  "EllipticCurve-ElGamal",
+  "Sander-Young-Yung",
+  "Boneh-Goh-Nissim",
 ]
 
 cs = LightPHE(algorithm_name = algorithms[0])

{lightphe-0.0.19 → lightphe-0.0.21}/README.md

@@ -20,7 +20,7 @@
 
 <p align="center"><img src="https://raw.githubusercontent.com/serengil/LightPHE/master/icons/phi.png" width="200" height="240"></p>
 
-LightPHE is a lightweight partially homomorphic encryption library for python. It is a hybrid homomoprhic encryption library wrapping many schemes such as [`RSA`](https://sefiks.com/2023/03/06/a-step-by-step-partially-homomorphic-encryption-example-with-rsa-in-python/), [`ElGamal`](https://sefiks.com/2023/03/27/a-step-by-step-partially-homomorphic-encryption-example-with-elgamal-in-python/), [`Exponential ElGamal`](https://sefiks.com/2023/03/27/a-step-by-step-partially-homomorphic-encryption-example-with-elgamal-in-python/), [`Elliptic Curve ElGamal`](https://sefiks.com/2018/08/21/elliptic-curve-elgamal-encryption/) ([`Weierstrass`](https://sefiks.com/2016/03/13/the-math-behind-elliptic-curve-cryptography/), [`Koblitz`](sefiks.com/2016/03/13/the-math-behind-elliptic-curves-over-binary-field/) and [`Edwards`](https://sefiks.com/2018/12/19/a-gentle-introduction-to-edwards-curves/) forms), [`Paillier`](https://sefiks.com/2023/04/03/a-step-by-step-partially-homomorphic-encryption-example-with-paillier-in-python/), [`Damgard-Jurik`](https://sefiks.com/2023/10/20/a-step-by-step-partially-homomorphic-encryption-example-with-damgard-jurik-in-python/), [`Okamoto–Uchiyama`](https://sefiks.com/2023/10/20/a-step-by-step-partially-homomorphic-encryption-example-with-okamoto-uchiyama-in-python/), [`Benaloh`](https://sefiks.com/2023/10/06/a-step-by-step-partially-homomorphic-encryption-example-with-benaloh-in-python-from-scratch/), [`Naccache–Stern`](https://sefiks.com/2023/10/26/a-step-by-step-partially-homomorphic-encryption-example-with-naccache-stern-in-python/), [`Goldwasser–Micali`](https://sefiks.com/2023/10/27/a-step-by-step-partially-homomorphic-encryption-example-with-goldwasser-micali-in-python/).
+LightPHE is a lightweight partially homomorphic encryption library for python. It is a hybrid homomoprhic encryption library wrapping many schemes such as [`RSA`](https://sefiks.com/2023/03/06/a-step-by-step-partially-homomorphic-encryption-example-with-rsa-in-python/), [`ElGamal`](https://sefiks.com/2023/03/27/a-step-by-step-partially-homomorphic-encryption-example-with-elgamal-in-python/), [`Exponential ElGamal`](https://sefiks.com/2023/03/27/a-step-by-step-partially-homomorphic-encryption-example-with-elgamal-in-python/), [`Elliptic Curve ElGamal`](https://sefiks.com/2018/08/21/elliptic-curve-elgamal-encryption/) ([`Weierstrass`](https://sefiks.com/2016/03/13/the-math-behind-elliptic-curve-cryptography/), [`Koblitz`](sefiks.com/2016/03/13/the-math-behind-elliptic-curves-over-binary-field/) and [`Edwards`](https://sefiks.com/2018/12/19/a-gentle-introduction-to-edwards-curves/) forms), [`Paillier`](https://sefiks.com/2023/04/03/a-step-by-step-partially-homomorphic-encryption-example-with-paillier-in-python/), [`Damgard-Jurik`](https://sefiks.com/2023/10/20/a-step-by-step-partially-homomorphic-encryption-example-with-damgard-jurik-in-python/), [`Okamoto–Uchiyama`](https://sefiks.com/2023/10/20/a-step-by-step-partially-homomorphic-encryption-example-with-okamoto-uchiyama-in-python/), [`Benaloh`](https://sefiks.com/2023/10/06/a-step-by-step-partially-homomorphic-encryption-example-with-benaloh-in-python-from-scratch/), [`Naccache–Stern`](https://sefiks.com/2023/10/26/a-step-by-step-partially-homomorphic-encryption-example-with-naccache-stern-in-python/), [`Goldwasser–Micali`](https://sefiks.com/2023/10/27/a-step-by-step-partially-homomorphic-encryption-example-with-goldwasser-micali-in-python/), `Sander-Young-Yung`, `Boneh-Goh-Nissim`.
 
 # Partially vs Fully Homomorphic Encryption
 
@@ -51,18 +51,20 @@ from lightphe import LightPHE
 
 In summary, LightPHE is covering following algorithms and these are partially homomorphic with respect to the operations mentioned in the following table.
 
-| Algorithm | Multiplicatively<br>Homomorphic | Additively<br>Homomorphic | Scalar Multiplication | Exclusively<br>Homomorphic | Regeneration<br>of Ciphertext |
-| --- | --- | --- | --- | --- | --- |
-| RSA | ✅ | ❌ | ❌ | ❌ | ❌ |
-| ElGamal | ✅ | ❌ | ❌ | ❌ | ✅ |
-| Exponential ElGamal | ❌ | ✅ | ✅ | ❌ | ✅ |
-| Elliptic Curve ElGamal | ❌ | ✅ | ✅ | ❌ | ❌ |
-| Paillier | ❌ | ✅ | ✅ | ❌ | ✅ |
-| Damgard-Jurik | ❌ | ✅ | ✅ | ❌ | ✅ |
-| Benaloh | ❌ | ✅ | ✅ | ❌ | ✅ |
-| Naccache-Stern | ❌ | ✅ | ✅ | ❌ | ✅ |
-| Okamoto-Uchiyama | ❌ | ✅ | ✅ | ❌ | ✅ |
-| Goldwasser-Micali | ❌ | ❌ | ❌ | ✅ | ❌ |
+| Algorithm | Multiplicatively<br>Homomorphic | Additively<br>Homomorphic | Scalar Multiplication | Bitwise-XOR Homomorphic | Bitwise-AND Homomorphic | Regeneration<br>of Ciphertext |
+| --- | --- | --- | --- | --- | --- | --- |
+| RSA | ✅ | ❌ | ❌ | ❌ | ❌ | ❌ |
+| ElGamal | ✅ | ❌ | ❌ | ❌ | ❌ | ✅ |
+| Exponential ElGamal | ❌ | ✅ | ✅ | ❌ | ❌ | ✅ |
+| Elliptic Curve ElGamal | ❌ | ✅ | ✅ | ❌ | ❌ | ✅ |
+| Paillier | ❌ | ✅ | ✅ | ❌ | ❌ | ✅ |
+| Damgard-Jurik | ❌ | ✅ | ✅ | ❌ | ❌ | ✅ |
+| Benaloh | ❌ | ✅ | ✅ | ❌ | ❌ | ✅ |
+| Naccache-Stern | ❌ | ✅ | ✅ | ❌ | ❌ | ✅ |
+| Okamoto-Uchiyama | ❌ | ✅ | ✅ | ❌ | ❌ | ✅ |
+| Goldwasser-Micali | ❌ | ❌ | ❌ | ✅ | ❌ | ✅  |
+| Sander-Young-Yung | ❌ | ❌ | ❌ | ❌ | ✅ | ✅ |
+| Boneh-Goh-Nissim | 1️⃣ | ✅ | ✅ | ❌ | ❌ | ✅ |
 
 # Building cryptosystem
 
@@ -79,7 +81,9 @@ algorithms = [
   "Benaloh",
   "Naccache-Stern",
   "Goldwasser-Micali",
-  "EllipticCurve-ElGamal"
+  "EllipticCurve-ElGamal",
+  "Sander-Young-Yung",
+  "Boneh-Goh-Nissim",
 ]
 
 cs = LightPHE(algorithm_name = algorithms[0])

{lightphe-0.0.19 → lightphe-0.0.21}/lightphe/__init__.py

@@ -28,13 +28,15 @@ 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.cryptosystems.SanderYoungYung import SanderYoungYung
+from lightphe.cryptosystems.BonehGohNissim import BonehGohNissim
 
 
 # pylint: disable=eval-used, simplifiable-if-expression, too-few-public-methods
 
 logger = Logger(module="lightphe/__init__.py")
 
-VERSION = "0.0.19"
+VERSION = "0.0.21"
 
 
 class LightPHE:
@@ -57,7 +59,7 @@ class LightPHE:
         Args:
             algorithm_name (str): RSA | ElGamal | Exponential-ElGamal | EllipticCurve-ElGamal
                 | Paillier | Damgard-Jurik | Okamoto-Uchiyama | Benaloh | Naccache-Stern
-                | Goldwasser-Micali
+                | Goldwasser-Micali | Sander-Young-Yung | Boneh-Goh-Nissim
             keys (dict): optional private-public key pair
             key_file (str): if keys were exported already, you can load them into cryptosystem
             key_size (int): key size in bits
@@ -116,13 +118,15 @@ class LightPHE:
         Benaloh,
         NaccacheStern,
         EllipticCurveElGamal,
+        SanderYoungYung,
+        BonehGohNissim,
     ]:
         """
         Build a cryptosystem among partially homomorphic algorithms
         Args:
             algorithm_name (str): RSA | ElGamal | Exponential-ElGamal | EllipticCurve-ElGamal
                 | Paillier | Damgard-Jurik | Okamoto-Uchiyama | Benaloh | Naccache-Stern
-                | Goldwasser-Micali | Edwards-ElGamal
+                | Goldwasser-Micali | Edwards-ElGamal | Sander-Young-Yung | Boneh-Goh-Nissim
                 Default is Paillier.
             keys (dict): optional private-public key pair
             key_file (str): if keys are exported, you can load them into cryptosystem
@@ -172,6 +176,12 @@ class LightPHE:
             cs = NaccacheStern(keys=keys, key_size=key_size, max_tries=max_tries)
         elif algorithm_name == Algorithm.GoldwasserMicali:
             cs = GoldwasserMicali(keys=keys, key_size=key_size, max_tries=max_tries)
+        elif algorithm_name == Algorithm.SanderYoungYung:
+            cs = SanderYoungYung(
+                keys=keys, key_size=key_size, plaintext_limit=plaintext_limit
+            )
+        elif algorithm_name == Algorithm.BonehGohNissim:
+            cs = BonehGohNissim(keys=keys, key_size=key_size, max_tries=max_tries)
         else:
             raise ValueError(f"unimplemented algorithm - {algorithm_name}")
         return cs

{lightphe-0.0.19 → lightphe-0.0.21}/lightphe/commons/phe_utils.py

@@ -23,6 +23,10 @@ def normalize_input(value: Union[int, float], modulo: Union[int, str]) -> int:
         # elliptic curve elgamal & koblitz curves
         result = value % int(modulo, 2)
     elif isinstance(value, int) and isinstance(modulo, int):
+        if value > modulo:
+            logger.warn(
+                f"Value {value} is greater than modulo {modulo}. Normalizing it to be in the range of modulo."
+            )
         result = value % modulo
     elif isinstance(value, float) and value >= 0:
         dividend, divisor = fractionize(value=value, modulo=modulo)

lightphe-0.0.21/lightphe/cryptosystems/BonehGohNissim.py

@@ -0,0 +1,327 @@
+# built-in dependencies
+import random
+import math
+from typing import Optional, Tuple, Union
+
+# third-party dependencies
+from lightecc import LightECC
+from lightecc.interfaces.elliptic_curve import EllipticCurvePoint
+from lightecc.commons.pairing import _fp2_pow, _fp2_mul
+import sympy
+from sympy.ntheory.residue_ntheory import sqrt_mod
+
+# project dependencies
+from lightphe.models.Homomorphic import Homomorphic
+from lightphe.commons.logger import Logger
+
+logger = Logger(module="lightphe/cryptosystems/BonehGohNissim.py")
+
+
+class BonehGohNissim(Homomorphic):
+    """
+    Boneh-Goh-Nissim algorithm is homomorphic with respect to the addition.
+        It's also somehow homomorphic with respect to the multiplication
+        only for one multiplication per ciphertext
+    TODO: add a tutorial for this algorithm
+    """
+
+    def __init__(
+        self,
+        keys: Optional[dict] = None,
+        key_size: Optional[int] = None,
+        max_tries: int = 10000,
+    ):
+        """
+        Args:
+            keys (dict): private - public key pair.
+                set this to None if you want to generate random keys.
+            key_size (int): size of the keys to generate in bits. Default is 1024.
+        """
+        self.keys = keys or self.generate_keys(
+            key_size=key_size or 1024,
+            max_tries=max_tries,
+        )
+
+        self.ec = LightECC(
+            form_name="weierstrass",
+            curve_name="custom",
+            config={
+                "a": self.keys["public_key"]["curve"]["a"],
+                "b": self.keys["public_key"]["curve"]["b"],
+                "p": self.keys["public_key"]["curve"]["p"],
+                "G": self.keys["public_key"]["curve"]["G"],
+                "n": self.keys["public_key"]["curve"]["n"],
+            },
+        )
+
+        self.plaintext_modulo = self.ec.modulo
+        self.ciphertext_modulo = self.ec.modulo
+
+    def generate_keys(
+        self,
+        key_size: int,
+        max_tries: int = 10000,
+    ):
+        """
+        Generate public and private keys of Boneh-Goh-Nissim cryptosystem
+        Returns:
+            keys (dict): having private_key and public_key keys
+        """
+        keys = {}
+        keys["private_key"] = {}
+        keys["public_key"] = {}
+
+        for key_attempt in range(max_tries):
+            # choose large odd distinct primes q1 and q2
+            q1 = sympy.randprime(2 ** (key_size // 2), 2 ** (key_size // 2 + 1))
+            q2 = sympy.randprime(2 ** (key_size // 2), 2 ** (key_size // 2 + 1))
+            while q1 == q2:
+                q2 = sympy.randprime(2 ** (key_size // 2), 2 ** (key_size // 2 + 1))
+
+            n = q1 * q2
+
+            # Find l such that p = n*l - 1 is prime and p ≡ 3 (mod 4).
+            # Supersingularity of y² = x³ + x requires p ≡ 3 (mod 4).
+            # Since n is odd (product of two odd primes), n*l ≡ 0 (mod 4)
+            # iff l ≡ 0 (mod 4). So we iterate multiples of 4 systematically.
+            l = None
+            for l_candidate in range(4, max_tries * 4 + 4, 4):
+                p_candidate = n * l_candidate - 1
+                if sympy.isprime(p_candidate):
+                    l = l_candidate
+                    break
+
+            if l is None:
+                logger.debug(
+                    f"No valid l found for attempt {key_attempt + 1}, retrying"
+                )
+                continue
+
+            p = n * l - 1
+            a = 1
+            b = 0
+
+            G = self.__find_generator(p, max_tries=max_tries)
+
+            # order of the curve may not be exactly n, but it should be
+            self.ec = LightECC(
+                form_name="weierstrass",
+                curve_name="custom",
+                config={"a": a, "b": b, "p": p, "G": G, "n": None},
+            )
+
+            nG = n * self.ec.G
+            if (
+                nG == self.ec.O
+            ):  # check if nG is the point at infinity / identity element / neutral element
+                logger.debug("nG is the point at infinity, as expected.")
+                logger.debug(f"q1 = {q1}, q2 = {q2}, n = {n}, p = {p}, l = {l}")
+                break
+
+            logger.debug(f"nG not infinity, retrying (attempt {key_attempt + 1})")
+        else:
+            raise Exception(f"Failed to generate keys after {max_tries} attempts")
+
+        while True:
+            r = random.randint(2, n - 1)
+            if math.gcd(r, n) == 1:
+                break
+
+        u = r * self.ec.G
+        h = u * q2
+
+        keys["public_key"]["curve"] = {
+            "a": a,
+            "b": b,
+            "p": p,
+            "G": G,
+            "n": n,
+        }
+
+        keys["private_key"]["q1"] = q1
+        keys["private_key"]["q2"] = q2
+        keys["public_key"]["G"] = G
+        keys["public_key"]["u"] = u.get_point()
+        keys["public_key"]["h"] = h.get_point()
+        keys["public_key"]["l"] = l
+        return keys
+
+    @staticmethod
+    def __find_generator(p, max_tries=10000) -> Tuple[int, int]:
+        if not sympy.isprime(p):
+            raise ValueError("p must be prime")
+
+        for _ in range(max_tries):
+            x = random.randint(0, p - 1)
+            rhs = (pow(x, 3, p) + x) % p
+            y_list = sqrt_mod(rhs, p, all_roots=True)  # get all square roots
+            if y_list:  # if there is at least one solution
+                return x, y_list[0]  # just return the first one
+
+        raise Exception(f"Failed to find a generator after {max_tries} attempts")
+
+    def generate_random_key(self) -> int:
+        """
+        Boneh-Goh-Nissim requires to generate one-time random key per encryption
+        Returns:
+            random key (int): one time random key for encryption
+        """
+        q2 = self.keys["private_key"]["q2"]
+        return random.randint(1, q2 - 1)
+
+    def encrypt(
+        self, plaintext: int, random_key: Optional[int] = None
+    ) -> EllipticCurvePoint:
+        """
+        Encrypt a given plaintext for optionally given random key with Boneh-Goh-Nissim
+        Args:
+            plaintext (int): message to encrypt
+            random_key (int): one time random key for encryption
+        Returns:
+            ciphertext (EllipticCurvePoint): encrypted message as a point on the elliptic curve
+        """
+        r = random_key or self.generate_random_key()
+        G = self.ec.G
+        h = self.keys["public_key"]["h"]
+        h = EllipticCurvePoint(x=h[0], y=h[1], curve=self.ec.curve)
+        c = (G * plaintext) + (h * r)
+        return c
+
+    def decrypt(self, ciphertext: Union[EllipticCurvePoint, Tuple[int, int]]) -> int:
+        """
+        Decrypt a given ciphertext with Boneh-Goh-Nissim.
+        Handles both G1 ciphertexts (EllipticCurvePoint, from encryption/addition)
+        and G_T ciphertexts (tuple in F_{p^2}, from homomorphic multiplication).
+
+        Args:
+            ciphertext: encrypted message — either an EllipticCurvePoint or
+                a tuple (a, b) representing a + b*i in F_{p^2}
+        Returns:
+            plaintext (int): restored message
+        """
+        q1 = self.keys["private_key"]["q1"]
+
+        if isinstance(ciphertext, tuple):
+            return self._decrypt_gt(ciphertext, q1)
+
+        G = self.ec.G
+
+        mP = ciphertext * q1
+        P = G * q1
+
+        for i in range(1, q1 + 1):
+            iP = P * i
+            if iP == mP:
+                return i
+
+        raise Exception("Decryption failed")
+
+    def _decrypt_gt(self, ciphertext: tuple, q1: int) -> int:
+        """
+        Decrypt a G_T ciphertext (result of homomorphic multiplication).
+
+        e(C1, C2)^q1 = e(G, G)^(q1 * m1 * m2)
+        Solve DLP: find m such that base^m == target, where
+            base = e(G, G)^q1
+            target = e(C1, C2)^q1
+
+        Args:
+            ciphertext: pairing value (a, b) in F_{p^2}
+            q1: private key component
+        Returns:
+            plaintext product m1 * m2
+        """
+        p = self.ec.modulo
+        G = self.ec.G
+
+        # e(G, G) — pairing of generator with itself via distortion map
+        e_gg = self.ec.pairing(G, G)
+
+        # base = e(G, G)^q1, target = e(C1, C2)^q1
+        base = _fp2_pow(e_gg, q1, p)
+        target = _fp2_pow(ciphertext, q1, p)
+
+        # brute-force DLP in G_T
+        acc = (1, 0)
+        for i in range(1, q1 + 1):
+            acc = _fp2_mul(acc, base, p)
+            if acc == target:
+                return i
+
+        raise Exception("Decryption of G_T ciphertext failed")
+
+    def add(
+        self, ciphertext1: EllipticCurvePoint, ciphertext2: EllipticCurvePoint
+    ) -> EllipticCurvePoint:
+        """
+        Add two ciphertexts with Boneh-Goh-Nissim
+        Args:
+            ciphertext1 (EllipticCurvePoint): first encrypted message as a point on the elliptic curve
+            ciphertext2 (EllipticCurvePoint): second encrypted message as a point on the elliptic curve
+        Returns:
+            result (tuple): resulting ciphertext after addition
+        """
+        return ciphertext1 + ciphertext2
+
+    def multiply(
+        self,
+        ciphertext1: EllipticCurvePoint,
+        ciphertext2: EllipticCurvePoint,
+    ) -> Tuple[int, int]:
+        """
+        Homomorphic multiplication of two ciphertexts using the bilinear pairing.
+        The result is an element of F_{p^2} (the pairing target group G_T),
+        not a point on the elliptic curve. BGN supports only one multiplication
+        per ciphertext — the result cannot be multiplied again.
+
+        Args:
+            ciphertext1: first encrypted message (point on E(F_p))
+            ciphertext2: second encrypted message (point on E(F_p))
+        Returns:
+            result (tuple): pairing value (a, b) representing a + b*i in F_{p^2}
+        """
+        # The tuple (a, b) represents a + b·i where i² = -1 mod p
+        if isinstance(ciphertext1, tuple) or isinstance(ciphertext2, tuple):
+            raise ValueError(
+                "Boneh-Goh-Nissim only supports multiplication ciphertexts once!"
+            )
+        result = self.ec.pairing(ciphertext1, ciphertext2)
+        if not isinstance(result, tuple):
+            raise ValueError(
+                "Boneh-Goh-Nissim requires a supersingular curve with embedding degree 2. "
+                "The pairing returned an F_p element instead of an F_{p^2} element."
+            )
+
+        # the pairing result is an element of F_{p²}, not a point on the curve.
+        # In BGN, the pairing maps two curve points to a field element
+        # (in the multiplicative group G_T). The result of e(C1, C2) lives
+        # in F_{p²}*, not on the elliptic curve. The homomorphic multiplication
+        # works in G_T (the target group of the pairing), not back on the curve.
+        return result
+
+    def multiply_by_constant(
+        self, ciphertext: EllipticCurvePoint, constant: int
+    ) -> EllipticCurvePoint:
+        """
+        Multiply a ciphertext by a constant with Boneh-Goh-Nissim
+        Args:
+            ciphertext (tuple): encrypted message as a tuple of two points on the elliptic curve
+            constant (int): constant to multiply with the ciphertext
+        Returns:
+            result (tuple): resulting ciphertext after multiplication
+        """
+        return ciphertext * constant
+
+    def reencrypt(self, ciphertext: EllipticCurvePoint) -> EllipticCurvePoint:
+        """
+        Re-encrypt a given ciphertext with Boneh-Goh-Nissim
+        Args:
+            ciphertext (tuple): encrypted message as a tuple of two points on the elliptic curve
+        Returns:
+            reencrypted_ciphertext (tuple): re-encrypted message as a tuple of two points on the elliptic curve
+        """
+        h = self.keys["public_key"]["h"]
+        h = EllipticCurvePoint(x=h[0], y=h[1], curve=self.ec.curve)
+        r = self.generate_random_key()
+        c_prime = ciphertext + (r * h)
+        return c_prime

{lightphe-0.0.19 → lightphe-0.0.21}/lightphe/cryptosystems/EllipticCurveElGamal.py

@@ -166,8 +166,6 @@ class EllipticCurveElGamal(Homomorphic):
 
         return a.get_point(), b.get_point()
 
-
-
     def multiply_by_constant(self, ciphertext: tuple, constant: int) -> tuple:
         """
         Multiply a ciphertext with a plain constant.
@@ -190,3 +188,25 @@ class EllipticCurveElGamal(Homomorphic):
         Q_prime = Q * constant
 
         return P_prime.get_point(), Q_prime.get_point()
+
+    def reencrypt(self, ciphertext: tuple) -> tuple:
+        """
+        Re-encrypt a ciphertext with a new random key
+        Args:
+            ciphertext (tuple): c1 and c2
+        Returns:
+            ciphertext (tuple): new c1 and c2
+        """
+        r_prime = self.generate_random_key()
+
+        x, y = self.keys["public_key"]["Qa"]
+        Qa = EllipticCurvePoint(x=x, y=y, curve=self.ecc.curve)
+
+        # c1 and c2 as tuple of integers
+        c1, c2 = ciphertext
+        c1 = EllipticCurvePoint(x=c1[0], y=c1[1], curve=self.ecc.curve)
+        c2 = EllipticCurvePoint(x=c2[0], y=c2[1], curve=self.ecc.curve)
+
+        c1_prime = c1 + r_prime * self.ecc.G
+        c2_prime = c2 + r_prime * Qa
+        return c1_prime.get_point(), c2_prime.get_point()

{lightphe-0.0.19 → lightphe-0.0.21}/lightphe/cryptosystems/GoldwasserMicali.py

@@ -171,16 +171,6 @@ class GoldwasserMicali(Homomorphic):
         m_binary = "".join(m_binaries)
         return int(m_binary, 2)
 
-    def add(self, ciphertext1: list, ciphertext2: list) -> list:
-        raise ValueError(
-            "Goldwasser-Micali is not homomorphic with respect to the addition"
-        )
-
-    def multiply(self, ciphertext1: int, ciphertext2: int) -> int:
-        raise ValueError(
-            "Goldwasser-Micali is not homomorphic with respect to the multiplication"
-        )
-
     def xor(self, ciphertext1: List[int], ciphertext2: List[int]) -> List[int]:
         """
         Perform homomorphic xor on encrypted data.
@@ -211,3 +201,21 @@ class GoldwasserMicali(Homomorphic):
             ciphertext3.append((c1 * c2) % self.ciphertext_modulo)
 
         return ciphertext3
+
+    def reencrypt(self, ciphertext: List[int]) -> List[int]:
+        """
+        Re-encrypt a given ciphertext with Goldwasser-Micali
+        Args:
+            ciphertext (int): encrypted message
+        Returns:
+            ciphertext (int): re-encrypted message
+        """
+        n = self.keys["public_key"]["n"]
+
+        c_reencrypted = []
+        for ci in ciphertext:
+            ri = self.generate_random_key()
+            ci_reencrypted = (pow(ri, 2, n) * ci) % n
+            c_reencrypted.append(ci_reencrypted)
+
+        return c_reencrypted