lightphe 0.0.21__tar.gz → 0.0.23__tar.gz

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: lightphe
-Version: 0.0.21
+Version: 0.0.23
 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/), `Sander-Young-Yung`, `Boneh-Goh-Nissim`.
+LightPHE is a lightweight homomorphic encryption library for python supporting various partially and somewhat homomorphic encryptions 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`](https://sefiks.com/2026/04/02/a-step-by-step-partially-homomorphic-sander-young-yung-example-in-python/), [`Boneh-Goh-Nissim`](https://sefiks.com/2026/04/02/a-step-by-step-somewhat-homomorphic-encryption-example-with-boneh-goh-nissim-in-python/).
 
 # Partially vs Fully Homomorphic Encryption
 

{lightphe-0.0.21 → lightphe-0.0.23}/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/), `Sander-Young-Yung`, `Boneh-Goh-Nissim`.
+LightPHE is a lightweight homomorphic encryption library for python supporting various partially and somewhat homomorphic encryptions 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`](https://sefiks.com/2026/04/02/a-step-by-step-partially-homomorphic-sander-young-yung-example-in-python/), [`Boneh-Goh-Nissim`](https://sefiks.com/2026/04/02/a-step-by-step-somewhat-homomorphic-encryption-example-with-boneh-goh-nissim-in-python/).
 
 # Partially vs Fully Homomorphic Encryption
 

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

@@ -36,7 +36,7 @@ from lightphe.cryptosystems.BonehGohNissim import BonehGohNissim
 
 logger = Logger(module="lightphe/__init__.py")
 
-VERSION = "0.0.21"
+VERSION = "0.0.23"
 
 
 class LightPHE:

{lightphe-0.0.21 → lightphe-0.0.23}/lightphe/cryptosystems/BonehGohNissim.py

@@ -21,8 +21,8 @@ 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
+        only for one multiplication per ciphertext.
+    Ref: https://sefiks.com/2026/04/02/a-step-by-step-somewhat-homomorphic-encryption-example-with-boneh-goh-nissim-in-python/
     """
 
     def __init__(
@@ -54,7 +54,10 @@ class BonehGohNissim(Homomorphic):
             },
         )
 
-        self.plaintext_modulo = self.ec.modulo
+        if "private_key" in self.keys and "q2" in self.keys["private_key"]:
+            self.plaintext_modulo = self.keys["private_key"]["q2"]
+        else:
+            self.plaintext_modulo = self.keys["public_key"]["curve"]["n"]
         self.ciphertext_modulo = self.ec.modulo
 
     def generate_keys(
@@ -160,14 +163,28 @@ class BonehGohNissim(Homomorphic):
 
         raise Exception(f"Failed to find a generator after {max_tries} attempts")
 
+    def _has_private_key(self) -> bool:
+        return "private_key" in self.keys and "q2" in self.keys["private_key"]
+
     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)
+        if self._has_private_key():
+            q2 = self.keys["private_key"]["q2"]
+            return random.randint(1, q2 - 1)
+
+        n = self.keys["public_key"]["curve"]["n"]
+        logger.warn(
+            "Private key is not available. Random key will be bounded by n"
+            " instead of q2. Encryption will work for small plaintexts,"
+            " but negative number encoding via plaintext_modulo will not"
+            " round-trip correctly because plaintext_modulo is set to n"
+            " (public) instead of q2 (private)."
+        )
+        return random.randint(1, n - 1)
 
     def encrypt(
         self, plaintext: int, random_key: Optional[int] = None
@@ -200,23 +217,28 @@ class BonehGohNissim(Homomorphic):
             plaintext (int): restored message
         """
         q1 = self.keys["private_key"]["q1"]
+        q2 = self.keys["private_key"]["q2"]
 
         if isinstance(ciphertext, tuple):
-            return self._decrypt_gt(ciphertext, q1)
+            return self._decrypt_gt(ciphertext, q1, q2)
 
         G = self.ec.G
 
         mP = ciphertext * q1
         P = G * q1
 
-        for i in range(1, q1 + 1):
+        # P has order q2, so DLP result is in [0, q2)
+        if mP == self.ec.O:
+            return 0
+
+        for i in range(1, q2):
             iP = P * i
             if iP == mP:
                 return i
 
         raise Exception("Decryption failed")
 
-    def _decrypt_gt(self, ciphertext: tuple, q1: int) -> int:
+    def _decrypt_gt(self, ciphertext: tuple, q1: int, q2: int) -> int:
         """
         Decrypt a G_T ciphertext (result of homomorphic multiplication).
 
@@ -241,9 +263,12 @@ class BonehGohNissim(Homomorphic):
         base = _fp2_pow(e_gg, q1, p)
         target = _fp2_pow(ciphertext, q1, p)
 
-        # brute-force DLP in G_T
+        # brute-force DLP in G_T — result is in [0, q2)
+        if target == (1, 0):
+            return 0
+
         acc = (1, 0)
-        for i in range(1, q1 + 1):
+        for i in range(1, q2):
             acc = _fp2_mul(acc, base, p)
             if acc == target:
                 return i
@@ -251,8 +276,10 @@ class BonehGohNissim(Homomorphic):
         raise Exception("Decryption of G_T ciphertext failed")
 
     def add(
-        self, ciphertext1: EllipticCurvePoint, ciphertext2: EllipticCurvePoint
-    ) -> EllipticCurvePoint:
+        self,
+        ciphertext1: Union[EllipticCurvePoint, Tuple[int, int]],
+        ciphertext2: Union[EllipticCurvePoint, Tuple[int, int]],
+    ) -> Union[EllipticCurvePoint, Tuple[int, int]]:
         """
         Add two ciphertexts with Boneh-Goh-Nissim
         Args:
@@ -261,7 +288,15 @@ class BonehGohNissim(Homomorphic):
         Returns:
             result (tuple): resulting ciphertext after addition
         """
-        return ciphertext1 + ciphertext2
+        if isinstance(ciphertext1, EllipticCurvePoint) and isinstance(
+            ciphertext2, EllipticCurvePoint
+        ):
+            return ciphertext1 + ciphertext2
+
+        if isinstance(ciphertext1, tuple) and isinstance(ciphertext2, tuple):
+            return _fp2_mul(ciphertext1, ciphertext2, self.ec.modulo)
+
+        raise ValueError("Both ciphertexts must be of the same type for addition.")
 
     def multiply(
         self,
@@ -300,8 +335,8 @@ class BonehGohNissim(Homomorphic):
         return result
 
     def multiply_by_constant(
-        self, ciphertext: EllipticCurvePoint, constant: int
-    ) -> EllipticCurvePoint:
+        self, ciphertext: Union[EllipticCurvePoint, Tuple[int, int]], constant: int
+    ) -> Union[EllipticCurvePoint, Tuple[int, int]]:
         """
         Multiply a ciphertext by a constant with Boneh-Goh-Nissim
         Args:
@@ -310,7 +345,20 @@ class BonehGohNissim(Homomorphic):
         Returns:
             result (tuple): resulting ciphertext after multiplication
         """
-        return ciphertext * constant
+        if isinstance(ciphertext, EllipticCurvePoint):
+            return ciphertext * constant
+        if isinstance(ciphertext, tuple):
+            # For GT elements, we can use exponentiation to achieve scalar multiplication
+            base = ciphertext
+            result = (1, 0)  # identity element in F_{p^2}*
+            for _ in range(constant):
+                result = _fp2_mul(result, base, self.ec.modulo)
+            return result
+
+        raise ValueError(
+            "Ciphertext must be either an EllipticCurvePoint or a tuple "
+            "representing an F_{p^2} element for multiplication by constant."
+        )
 
     def reencrypt(self, ciphertext: EllipticCurvePoint) -> EllipticCurvePoint:
         """

{lightphe-0.0.21 → lightphe-0.0.23}/lightphe/cryptosystems/SanderYoungYung.py

@@ -17,8 +17,8 @@ logger = Logger(module="lightphe/cryptosystems/SanderYoungYung.py")
 
 class SanderYoungYung(Homomorphic):
     """
-    Sander-Young-Yung algorithm is homomorphic with respect to the addition.
-    TODO: add a tutorial for this algorithm.
+    Sander-Young-Yung algorithm is homomorphic with respect to bitwise AND.
+        Ref: https://sefiks.com/2026/04/02/a-step-by-step-partially-homomorphic-sander-young-yung-example-in-python/
     """
 
     def __init__(

{lightphe-0.0.21 → lightphe-0.0.23}/lightphe.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: lightphe
-Version: 0.0.21
+Version: 0.0.23
 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/), `Sander-Young-Yung`, `Boneh-Goh-Nissim`.
+LightPHE is a lightweight homomorphic encryption library for python supporting various partially and somewhat homomorphic encryptions 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`](https://sefiks.com/2026/04/02/a-step-by-step-partially-homomorphic-sander-young-yung-example-in-python/), [`Boneh-Goh-Nissim`](https://sefiks.com/2026/04/02/a-step-by-step-somewhat-homomorphic-encryption-example-with-boneh-goh-nissim-in-python/).
 
 # Partially vs Fully Homomorphic Encryption
 

{lightphe-0.0.21 → lightphe-0.0.23}/setup.py

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

{lightphe-0.0.21 → lightphe-0.0.23}/tests/test_benaloh.py

@@ -1,44 +1,13 @@
 import pytest
-from lightphe.cryptosystems.Benaloh import Benaloh
 from lightphe.commons.logger import Logger
 
 logger = Logger(module="tests/test_benaloh.py")
 
 
-def test_benaloh():
-    bn = Benaloh()
-
-    m1 = bn.plaintext_modulo + 18
-    m2 = bn.plaintext_modulo + 22
-
-    c1 = bn.encrypt(m1)
-    c2 = bn.encrypt(m2)
-
-    # supported homomorphic operations
-    assert bn.decrypt(bn.add(c1, c2)) == (m1 + m2) % bn.plaintext_modulo
-    assert (
-        bn.decrypt(bn.multiply_by_constant(c1, m2)) == (m1 * m2) % bn.plaintext_modulo
-    )
-
-    # unsupported homomorphic operations
-    with pytest.raises(ValueError):
-        bn.multiply(c1, m2)
-
-    with pytest.raises(ValueError):
-        bn.xor(c1, c2)
-
-    # re-encryption
-    c1_prime = bn.reencrypt(c1)
-    assert c1_prime != c1
-    assert bn.decrypt(c1_prime) == m1 % bn.plaintext_modulo
-
-    logger.info("✅ Benaloh test succeeded")
-
-
 def test_api():
     from lightphe import LightPHE
 
-    cs = LightPHE(algorithm_name="Benaloh")  # , key_size=50)
+    cs = LightPHE(algorithm_name="Benaloh", key_size=50)
 
     n = cs.cs.keys["public_key"]["n"]
     r = cs.cs.keys["public_key"]["r"]

lightphe-0.0.23/tests/test_bonehgohnissim.py

@@ -0,0 +1,251 @@
+import time
+
+import pytest
+
+from lightphe import LightPHE
+from lightphe.commons.logger import Logger
+
+logger = Logger(module="tests/test_bonehgodnissim.py")
+
+cs = LightPHE(
+    algorithm_name="Boneh-Goh-Nissim",
+    key_size=50,
+    max_tries=10000,
+)
+security_level = cs.cs.ec.n.bit_length()
+
+
+def test_api():
+    tic = time.time()
+
+    m1 = 83
+    m2 = 31
+
+    c1 = cs.encrypt(plaintext=m1)
+    c2 = cs.encrypt(plaintext=m2)
+
+    # proof of decryption
+    assert cs.decrypt(c1) == m1
+    assert cs.decrypt(c2) == m2
+
+    # homomorphic addition
+    assert cs.decrypt(c1 + c2) == (m1 + m2) % cs.cs.plaintext_modulo
+
+    # homomorphic multiplication (once)
+    c1_times_c2 = c1 * c2
+    assert cs.decrypt(c1_times_c2) == (m1 * m2) % cs.cs.plaintext_modulo
+
+    # scalar multiplication
+    k = 2
+    assert cs.decrypt(c1 * k) == (m1 * k) % cs.cs.plaintext_modulo
+
+    # unsupported homomorphic operations
+    with pytest.raises(
+        ValueError,
+        match="Boneh-Goh-Nissim only supports multiplication ciphertexts once!",
+    ):
+        _ = c1_times_c2 * c2
+
+    with pytest.raises(ValueError):
+        _ = c1 & c2
+
+    with pytest.raises(ValueError):
+        _ = c1 ^ c2
+
+    # re-randomization
+    c1_prime = cs.cs.reencrypt(c1.value)
+    c2_prime = cs.cs.reencrypt(c2.value)
+    # assert c1.value != c1_prime
+    # assert c2.value != c2_prime
+    assert cs.cs.decrypt(c1_prime) == m1
+    assert cs.cs.decrypt(c2_prime) == m2
+
+    logger.info(
+        f"✅ Boneh-God-Nissim test succeeded ({security_level} bit ECC security level)"
+        f" in {time.time() - tic:.2f} seconds"
+    )
+
+
+def test_linear_regression():
+    tic = time.time()
+
+    x1 = 5
+    w1 = 7
+
+    x2 = 3
+    w2 = 4
+
+    x1_enc = cs.encrypt(plaintext=x1)
+    w1_enc = cs.encrypt(plaintext=w1)
+
+    x2_enc = cs.encrypt(plaintext=x2)
+    w2_enc = cs.encrypt(plaintext=w2)
+
+    x1w1_enc = x1_enc * w1_enc
+    x2w2_enc = x2_enc * w2_enc
+
+    sum_enc = x1w1_enc + x2w2_enc
+
+    sum_decrypted = cs.decrypt(sum_enc)
+
+    assert sum_decrypted == (x1 * w1 + x2 * w2)
+
+    # multiplication by constant
+    _5x1w1_enc = cs.decrypt(x1w1_enc * 5)
+    assert _5x1w1_enc == (5 * x1 * w1)
+
+    # unsupported homomorphic operations
+    with pytest.raises(
+        ValueError,
+        match="Boneh-Goh-Nissim only supports multiplication ciphertexts once!",
+    ):
+        _ = x1w1_enc * w2_enc
+
+    logger.info(
+        f"✅ Boneh-God-Nissim linear regression test succeeded "
+        f"({security_level} bit ECC security level)"
+        f" in {time.time() - tic:.2f} seconds"
+    )
+
+
+def test_cosine_similarity():
+    tic = time.time()
+    i1 = 5
+    i2 = 2
+    i3 = 8
+
+    # v2 = [1, 1, 2]
+    j1 = 1
+    j2 = 1
+    j3 = 2
+
+    i1_enc = cs.encrypt(i1)
+    i2_enc = cs.encrypt(i2)
+    i3_enc = cs.encrypt(i3)
+
+    j1_enc = cs.encrypt(j1)
+    j2_enc = cs.encrypt(j2)
+    j3_enc = cs.encrypt(j3)
+
+    # homomorphic operation
+    cosine_sim_enc = i1_enc * j1_enc + i2_enc * j2_enc + i3_enc * j3_enc
+
+    # proof of work
+    assert cs.decrypt(cosine_sim_enc) == i1 * j1 + i2 * j2 + i3 * j3
+
+    logger.info(
+        f"✅ Boneh-God-Nissim cosine similarity test succeeded "
+        f"({security_level} bit ECC security level)"
+        f" in {time.time() - tic:.2f} seconds"
+    )
+
+
+def test_euclidean_distance():
+    tic = time.time()
+
+    # v1 = [5, 2, 3]
+    i1 = 5
+    i2 = 2
+    i3 = 8
+
+    # v2 = [1, 1, 2]
+    j1 = 1
+    j2 = 1
+    j3 = 2
+
+    i1_enc = cs.encrypt(i1)
+    i2_enc = cs.encrypt(i2)
+    i3_enc = cs.encrypt(i3)
+
+    j1_enc = cs.encrypt(-j1)
+    j2_enc = cs.encrypt(-j2)
+    j3_enc = cs.encrypt(-j3)
+
+    euclidean_sqrt_enc = (
+        (i1_enc + j1_enc) * (i1_enc + j1_enc)
+        + (i2_enc + j2_enc) * (i2_enc + j2_enc)
+        + (i3_enc + j3_enc) * (i3_enc + j3_enc)
+    )
+
+    assert (
+        cs.decrypt(euclidean_sqrt_enc)
+        == (i1 - j1) ** 2 + (i2 - j2) ** 2 + (i3 - j3) ** 2
+    )
+
+    logger.info(
+        f"✅ Boneh-God-Nissim euclidean distance test succeeded "
+        f"({security_level} bit ECC security level)"
+        f" in {time.time() - tic:.2f} seconds"
+    )
+
+
+def test_api_with_predefined_keys():
+    keys = {
+        "private_key": {"q1": 1260048562698661, "q2": 1495813357973021},
+        "public_key": {
+            "curve": {
+                "a": 1,
+                "b": 0,
+                "p": 1477681217875020437035023206706703,
+                "G": (
+                    404050258967758769169929337984186,
+                    548422986186523785500578682099939,
+                ),
+                "n": 1884797471779362802340590824881,
+            },
+            "G": (404050258967758769169929337984186, 548422986186523785500578682099939),
+            "u": (
+                496699107331579016081758964967239,
+                1209427529257066171815901459972102,
+            ),
+            "h": (557434130026147587760748115479880, 109859910481881270030204038710204),
+            "l": 784,
+        },
+    }
+
+    bgn_cs = LightPHE(
+        algorithm_name="Boneh-Goh-Nissim",
+        keys=keys,
+    )
+    security_level = bgn_cs.cs.ec.n.bit_length()
+
+    m1 = 3
+    m2 = 2
+
+    c1 = bgn_cs.encrypt(plaintext=m1)
+    c2 = bgn_cs.encrypt(plaintext=m2)
+
+    # proof of decryption
+    assert bgn_cs.decrypt(c1) == m1
+    assert bgn_cs.decrypt(c2) == m2
+
+    # homomorphic addition
+    assert bgn_cs.decrypt(c1 + c2) == (m1 + m2) % bgn_cs.cs.plaintext_modulo
+
+    # homomorphic multiplication
+    c1_times_c2 = c1 * c2
+    assert bgn_cs.decrypt(c1_times_c2) == (m1 * m2) % bgn_cs.cs.plaintext_modulo
+
+    # scalar multiplication
+    k = 2
+    assert bgn_cs.decrypt(c1 * k) == (m1 * k) % bgn_cs.cs.plaintext_modulo
+
+    # unsupported homomorphic operations
+
+    with pytest.raises(ValueError):
+        _ = c1 & c2
+
+    with pytest.raises(ValueError):
+        _ = c1 ^ c2
+
+    # re-randomization
+    c1_prime = bgn_cs.cs.reencrypt(c1.value)
+    c2_prime = bgn_cs.cs.reencrypt(c2.value)
+    # assert c1.value != c1_prime
+    # assert c2.value != c2_prime
+    assert bgn_cs.cs.decrypt(c1_prime) == m1
+    assert bgn_cs.cs.decrypt(c2_prime) == m2
+
+    logger.info(
+        f"✅ Boneh-God-Nissim test succeeded ({security_level} bit ECC security level)"
+    )

{lightphe-0.0.21 → lightphe-0.0.23}/tests/test_ciphertexts.py

@@ -6,10 +6,10 @@ from lightphe.commons.logger import Logger
 
 logger = Logger(module="tests/test_ciphertexts.py")
 
+onprem_cs = LightPHE(algorithm_name="Paillier", key_size=50)
 
-def test_private_key_not_available_in_ciphertext():
-    onprem_cs = LightPHE(algorithm_name="Paillier")
 
+def test_private_key_not_available_in_ciphertext():
     m = 17
 
     c = onprem_cs.encrypt(m)
@@ -21,8 +21,6 @@ def test_private_key_not_available_in_ciphertext():
 
 
 def test_private_key_not_available_in_encrypted_tensor():
-    onprem_cs = LightPHE(algorithm_name="Paillier")
-
     t = [1.5, 2.4, 3.3, 4.2, 5.1]
 
     c = onprem_cs.encrypt(t, silent=True)

lightphe-0.0.23/tests/test_damgard.py

@@ -0,0 +1,34 @@
+import pytest
+from lightphe.commons.logger import Logger
+
+logger = Logger(module="tests/test_damgard.py")
+
+
+def test_api():
+    from lightphe import LightPHE
+
+    cs = LightPHE(algorithm_name="Damgard-Jurik", key_size=50)
+
+    m1 = 17
+    m2 = 21
+
+    c1 = cs.encrypt(plaintext=m1)
+    c2 = cs.encrypt(plaintext=m2)
+
+    # homomorphic addition
+    assert cs.decrypt(c1 + c2) == m1 + m2
+
+    # homomorphic scalar multiplication
+    assert cs.decrypt(c1 * m2) == m1 * m2
+    assert cs.decrypt(c2 * m1) == m1 * m2
+    assert cs.decrypt(m2 * c1) == m1 * m2
+    assert cs.decrypt(m1 * c2) == m1 * m2
+
+    # unsupported homomorphic operations
+    with pytest.raises(ValueError):
+        _ = c1 * c2
+
+    with pytest.raises(ValueError):
+        _ = c1 ^ c2
+
+    logger.info("✅ Damgard-Jurik api test succeeded")

lightphe-0.0.23/tests/test_elgamal.py

@@ -0,0 +1,64 @@
+import pytest
+from lightphe.commons.logger import Logger
+
+logger = Logger(module="tests/test_elgamal.py")
+
+
+def test_api_for_multiplicative():
+    from lightphe import LightPHE
+
+    cs = LightPHE(algorithm_name="ElGamal", key_size=50)
+
+    m1 = 17
+    m2 = 21
+
+    c1 = cs.encrypt(plaintext=m1)
+    c2 = cs.encrypt(plaintext=m2)
+
+    # homomorphic addition
+    assert cs.decrypt(c1 * c2) == m1 * m2
+
+    # unsupported homomorphic operations
+    with pytest.raises(ValueError):
+        _ = c1 + c2
+
+    with pytest.raises(ValueError):
+        _ = c1 ^ c2
+
+    with pytest.raises(ValueError):
+        _ = c1 * 5
+
+    with pytest.raises(ValueError):
+        _ = 5 * c1
+
+    logger.info("✅ ElGamal api test succeeded")
+
+
+def test_api_for_additive():
+    from lightphe import LightPHE
+
+    cs = LightPHE(algorithm_name="Exponential-ElGamal", key_size=50)
+
+    m1 = 17
+    m2 = 21
+
+    c1 = cs.encrypt(plaintext=m1)
+    c2 = cs.encrypt(plaintext=m2)
+
+    # homomorphic addition
+    assert cs.decrypt(c1 + c2) == m1 + m2
+
+    # scalar multiplication
+    assert cs.decrypt(c1 * m2) == m1 * m2
+    assert cs.decrypt(c2 * m1) == m1 * m2
+    assert cs.decrypt(m2 * c1) == m1 * m2
+    assert cs.decrypt(m1 * c2) == m1 * m2
+
+    # unsupported homomorphic operations
+    with pytest.raises(ValueError):
+        _ = c1 * c2
+
+    with pytest.raises(ValueError):
+        _ = c1 ^ c2
+
+    logger.info("✅ Exponential ElGamal api test succeeded")