lightphe 0.0.17__tar.gz → 0.0.18__tar.gz

{lightphe-0.0.17 → lightphe-0.0.18}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: lightphe
-Version: 0.0.17
+Version: 0.0.18
 Summary: A Lightweight Partially Homomorphic Encryption Library for Python
 Home-page: https://github.com/serengil/LightPHE
 Author: Sefik Ilkin Serengil

{lightphe-0.0.17 → lightphe-0.0.18}/lightphe/__init__.py

@@ -9,10 +9,6 @@ import copy
 
 # 3rd party dependencies
 from tqdm import tqdm
-from lightecc.interfaces.elliptic_curve import EllipticCurvePoint
-from lightecc.forms.weierstrass import Weierstrass
-from lightecc.forms.edwards import TwistedEdwards
-from lightecc.forms.koblitz import Koblitz
 
 # project dependencies
 from lightphe.models.Homomorphic import Homomorphic
@@ -38,7 +34,7 @@ from lightphe.cryptosystems.EllipticCurveElGamal import EllipticCurveElGamal
 
 logger = Logger(module="lightphe/__init__.py")
 
-VERSION = "0.0.17"
+VERSION = "0.0.18"
 
 
 class LightPHE:
@@ -53,6 +49,7 @@ class LightPHE:
         precision: int = 5,
         form: Optional[str] = None,
         curve: Optional[str] = None,
+        plaintext_limit: Optional[int] = None,
     ):
         """
         Build LightPHE class
@@ -61,7 +58,7 @@ class LightPHE:
                 | Paillier | Damgard-Jurik | Okamoto-Uchiyama | Benaloh | Naccache-Stern
                 | Goldwasser-Micali
             keys (dict): optional private-public key pair
-            key_file (str): if keys are exported, you can load them into cryptosystem
+            key_file (str): if keys were exported already, you can load them into cryptosystem
             key_size (int): key size in bits
             precision (int): precision for homomorphic operations on tensors
             form (str): specifies the form of the elliptic curve.
@@ -73,8 +70,10 @@ class LightPHE:
                  - 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
+                    https://github.com/serengil/LightECC?tab=readme-ov-file#supported-curves
                 This parameter is only used if `algorithm_name` is 'EllipticCurve-ElGamal'.
+            plaintext_limit (int, optional): Upper bound for plaintext values.
+                This parameter is only used if `algorithm_name` is 'Benaloh'.
         """
         self.algorithm_name = algorithm_name
         self.precision = precision
@@ -90,6 +89,7 @@ class LightPHE:
             key_size=key_size,
             form=form,
             curve=curve,
+            plaintext_limit=plaintext_limit,
         )
 
     def __build_cryptosystem(
@@ -99,6 +99,7 @@ class LightPHE:
         key_size: Optional[int] = None,
         form: Optional[str] = None,
         curve: Optional[str] = None,
+        plaintext_limit: Optional[int] = None,
     ) -> Union[
         RSA,
         ElGamal,
@@ -148,7 +149,7 @@ class LightPHE:
         elif algorithm_name == Algorithm.OkamotoUchiyama:
             cs = OkamotoUchiyama(keys=keys, key_size=key_size)
         elif algorithm_name == Algorithm.Benaloh:
-            cs = Benaloh(keys=keys, key_size=key_size)
+            cs = Benaloh(keys=keys, key_size=key_size, plaintext_limit=plaintext_limit)
         elif algorithm_name == Algorithm.NaccacheStern:
             cs = NaccacheStern(keys=keys, key_size=key_size)
         elif algorithm_name == Algorithm.GoldwasserMicali:

{lightphe-0.0.17 → lightphe-0.0.18}/lightphe/cryptosystems/Benaloh.py

@@ -15,19 +15,33 @@ logger = Logger(module="lightphe/cryptosystems/Benaloh.py")
 
 
 class Benaloh(Homomorphic):
-    def __init__(self, keys: Optional[dict] = None, key_size: Optional[int] = None):
+    def __init__(
+        self,
+        keys: Optional[dict] = None,
+        key_size: Optional[int] = None,
+        plaintext_limit: Optional[int] = None,
+    ):
         """
         Args:
             keys (dict): private - public key pair.
                 set this to None if you want to generate random keys.
-            key_size (int): key size in bits. default is less than other cryptosystems
-                because decryption of Benaloh requires to solve DLP :/
-        """
-        self.keys = keys or self.generate_keys(key_size or 1024)
+            key_size (int): key size in bits.
+            plaintext_limit (int, optional): Upper bound for plaintext values.
+                If provided, r is set to the next prime greater than this value;
+                otherwise, r is chosen randomly from a default range.
+        """
+        self.keys = keys or self.generate_keys(
+            key_size=key_size or 1024, plaintext_limit=plaintext_limit
+        )
         self.plaintext_modulo = self.keys["public_key"]["r"]
         self.ciphertext_modulo = self.keys["public_key"]["n"]
 
-    def generate_keys(self, key_size: int, max_tries: int = 10000) -> dict:
+    def generate_keys(
+        self,
+        key_size: int,
+        max_tries: int = 10000,
+        plaintext_limit: Optional[int] = None,
+    ) -> dict:
         """
         Generate public and private keys of Paillier cryptosystem
         Args:
@@ -49,8 +63,10 @@ class Benaloh(Homomorphic):
             phi = (p - 1) * (q - 1)
 
             # generate block size r
-            # TODO: consider to get limit from user
-            r = sympy.randprime(1000, 2000)
+            if plaintext_limit is None:
+                r = sympy.randprime(1000, 2000)
+            else:
+                r = sympy.nextprime(plaintext_limit)
             # plaintexts will be allowed in [0, r-1]
 
             # block size r checks
@@ -58,7 +74,7 @@ class Benaloh(Homomorphic):
                 # r should divide p-1 without remainder
                 (p - 1) % r == 0
                 # r and (p - 1) / r must be coprimes
-                and gcd(r, int((p - 1) / r)) == 1
+                and gcd(r, int((p - 1) // r)) == 1
                 # r and q-1 must be coprimes
                 and gcd(r, q - 1) == 1
             ):
@@ -86,7 +102,7 @@ class Benaloh(Homomorphic):
         else:
             raise RuntimeError(
                 f"Failed to generate Benaloh keys after {max_tries} attempts."
-                "Please try to rerun."
+                f"Please try to rerun or consider to decrese {plaintext_limit=}."
             )
 
         keys["public_key"]["y"] = y

{lightphe-0.0.17 → lightphe-0.0.18}/lightphe/cryptosystems/GoldwasserMicali.py

@@ -33,7 +33,11 @@ class GoldwasserMicali(Homomorphic):
 
         self.keys = keys or self.generate_keys(key_size or 1024)
         self.ciphertext_modulo = self.keys["public_key"]["n"]
-        # TODO: not sure about the plaintext modulo
+
+        # Plaintext can be any integer (even larger than n) because it is internally
+        # encrypted bit by bit. Internally, each bit uses modulo 2, but LightPHE expects
+        # integers, not bits. The original integer can be fully restored after decryption
+        # even if it is larger than n.
         self.plaintext_modulo = self.keys["public_key"]["n"]
 
     def generate_keys(self, key_size: int, max_tries: int = 10000) -> dict:

{lightphe-0.0.17 → lightphe-0.0.18}/lightphe/models/Homomorphic.py

@@ -15,7 +15,11 @@ class Homomorphic(ABC):
 
     @abstractmethod
     def generate_keys(
-        self, key_size: int, s: Optional[int] = None, max_retries: Optional[int] = None
+        self,
+        key_size: int,
+        s: Optional[int] = None,
+        max_retries: Optional[int] = None,
+        plaintext_limit: Optional[int] = None,
     ) -> dict:
         pass
 

{lightphe-0.0.17 → lightphe-0.0.18}/lightphe.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: lightphe
-Version: 0.0.17
+Version: 0.0.18
 Summary: A Lightweight Partially Homomorphic Encryption Library for Python
 Home-page: https://github.com/serengil/LightPHE
 Author: Sefik Ilkin Serengil

{lightphe-0.0.17 → lightphe-0.0.18}/lightphe.egg-info/SOURCES.txt

@@ -36,6 +36,7 @@ tests/test_ellipticcurveelgamal.py
 tests/test_exporting_keys.py
 tests/test_goldwasser.py
 tests/test_keys.py
+tests/test_large_keys.py
 tests/test_naccache.py
 tests/test_okamoto.py
 tests/test_paillier.py

{lightphe-0.0.17 → lightphe-0.0.18}/setup.py

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

lightphe-0.0.18/tests/test_large_keys.py

@@ -0,0 +1,76 @@
+import time
+import unittest
+
+from lightphe import LightPHE
+from lightphe.commons.logger import Logger
+
+logger = Logger(module="tests/test_large_keys.py")
+
+
+@unittest.skip("This is an experimental test for large key sizes.")
+def test_large_keys():
+    """
+    Use this test to see no problem for larger keys.
+
+    Algorithm| Key Size | Key Generation Time | Encryption Time | Homomorphic Time | Decryption Time
+    --- | --- | --- | --- | --- | ---
+    Goldwasser-Micali | 1024 | 0.01 | 0.00 | 0.00 |0.00
+    Goldwasser-Micali | 2048 | 0.08 | 0.00 | 0.00 |0.03
+    Goldwasser-Micali | 3072 | 0.45 | 0.00 | 0.00 |0.08
+    Goldwasser-Micali | 7680 | 11.30 | 0.00 | 0.00 |1.21
+
+    Benaloh | 1024 | 4.91 | 0.00 | 0.00 |0.01
+    Benaloh | 2048 | 140.54 | 0.00 | 0.00 |0.03
+    Benaloh | 3072 | 439.46 | 0.00 | 0.00 |0.08
+    """
+    algorithms = [
+        # "Naccache-Stern",
+        # "Goldwasser-Micali",
+        "Benaloh",
+    ]
+    # key_sizes = [1024, 2048, 3072, 7680]
+    key_sizes = [3072, 7680]
+
+    for key_size in key_sizes:
+        for algorithm_name in algorithms:
+            logger.debug(f"Testing {algorithm_name} with key size {key_size} bits")
+            tic = time.time()
+            cs = LightPHE(algorithm_name=algorithm_name, key_size=key_size)
+            toc = time.time()
+            keygen_time = toc - tic
+
+            m1 = 17
+            m2 = 23
+
+            tic = time.time()
+            c1 = cs.encrypt(m1)
+            c2 = cs.encrypt(m2)
+            toc = time.time()
+            encryption_time = toc - tic
+
+            if algorithm_name in ["Naccache-Stern", "Benaloh"]:
+                tic = time.time()
+                c3 = c1 + c2
+                toc = time.time()
+                homomorphic_time = toc - tic
+
+                tic = time.time()
+                result = cs.decrypt(c3)
+                toc = time.time()
+                decryption_time = toc - tic
+                assert result == m1 + m2
+            elif algorithm_name in ["Goldwasser-Micali"]:
+                tic = time.time()
+                c3 = c1 ^ c2
+                toc = time.time()
+                homomorphic_time = toc - tic
+
+                tic = time.time()
+                result = cs.decrypt(c3)
+                toc = time.time()
+                decryption_time = toc - tic
+                assert result == m1 ^ m2
+
+            logger.info(
+                f"{algorithm_name} | {key_size} | {keygen_time:.2f} | {encryption_time:.2f} | {homomorphic_time:.2f} |{decryption_time:.2f}"
+            )