lightphe 0.0.17__tar.gz → 0.0.19__tar.gz

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: lightphe
-Version: 0.0.17
+Version: 0.0.19
 Summary: A Lightweight Partially Homomorphic Encryption Library for Python
 Home-page: https://github.com/serengil/LightPHE
 Author: Sefik Ilkin Serengil
@@ -129,7 +129,7 @@ assert cs.decrypt(c3) == m1 + m2
 assert cs.decrypt(c4) == k * m1
 ```
 
-On the other hand, if you adopt a multiplicatively homomorphic cryptosyste (e.g. RSA or ElGamal), you can multiply ciphertexts without revealing the private key or the plaintext.
+On the other hand, if you adopt a multiplicatively homomorphic cryptosystem (e.g. RSA or ElGamal), you can multiply ciphertexts without revealing the private key or the plaintext.
 
 ```python
 # build a multiplicatively homomorphic cryptosystem
@@ -152,7 +152,7 @@ assert cs.decrypt(c3) == m1 * m2
 
 ### Ciphertext Regeneration
 
-Similar to the most of additively homomorphic algorithms, Paillier lets you to regenerate ciphertext while you are not breaking its plaintext restoration. You may consider to do this re-generation many times to have stronger ciphertexts.
+The most of additively homomorphic algorithms allow you to regenerate ciphertext while you are not breaking its plaintext restoration. You may consider to do this re-generation many times to have stronger ciphertexts.
 
 ```python
 c1_prime = cs.regenerate_ciphertext(c1)
@@ -163,7 +163,7 @@ assert cs.decrypt(c1) == m1
 
 ### Elliptic Curve Cryptography
 
-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.
+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 (default), edwards and koblitz) and 100+ standard elliptic curve configurations.
 
 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.
 
@@ -171,7 +171,8 @@ In LightPHE, the [Elliptic Curve ElGamal](https://sefiks.com/2018/08/21/elliptic
 forms = ["weierstrass", "edwards", "koblitz"]
 phe = LightPHE(
     algorithm_name="EllipticCurve-ElGamal",
-    form=forms[1],
+    form="edwards",
+    # curve="ed448", # optinally you can specify the curve for given form
 )
 ```
 
@@ -204,12 +205,16 @@ c4 = c1 + c2
 c5 = 3 * c1
 
 # perform element-wise multiplication between an encrypted embedding and plain embedding
-c6 = c1 * t3  # Encrypted-plaintext multiplication
+c6 = c1 * t3
+
+# encrypted dot product (likewise cosine similarity)
+c7 = c1 @ t3
 
 # proof of work
 assert np.allclose(cs.decrypt(c4), [a + b for a, b in zip(t1, t2)], rtol=1e-2)
 assert np.allclose(cs.decrypt(c5), [a * 3 for a in t1], rtol=1e-2)
 assert np.allclose(cs.decrypt(c6), [a * b for a, b in zip(t1, t3)], rtol=1e-2)
+assert np.allclose(cs.decrypt(c7)[0], sum([a * b for a, b in zip(t1, t3)]), rtol=1e-2)
 ```
 
 # Contributing

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

@@ -113,7 +113,7 @@ assert cs.decrypt(c3) == m1 + m2
 assert cs.decrypt(c4) == k * m1
 ```
 
-On the other hand, if you adopt a multiplicatively homomorphic cryptosyste (e.g. RSA or ElGamal), you can multiply ciphertexts without revealing the private key or the plaintext.
+On the other hand, if you adopt a multiplicatively homomorphic cryptosystem (e.g. RSA or ElGamal), you can multiply ciphertexts without revealing the private key or the plaintext.
 
 ```python
 # build a multiplicatively homomorphic cryptosystem
@@ -136,7 +136,7 @@ assert cs.decrypt(c3) == m1 * m2
 
 ### Ciphertext Regeneration
 
-Similar to the most of additively homomorphic algorithms, Paillier lets you to regenerate ciphertext while you are not breaking its plaintext restoration. You may consider to do this re-generation many times to have stronger ciphertexts.
+The most of additively homomorphic algorithms allow you to regenerate ciphertext while you are not breaking its plaintext restoration. You may consider to do this re-generation many times to have stronger ciphertexts.
 
 ```python
 c1_prime = cs.regenerate_ciphertext(c1)
@@ -147,7 +147,7 @@ assert cs.decrypt(c1) == m1
 
 ### Elliptic Curve Cryptography
 
-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.
+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 (default), edwards and koblitz) and 100+ standard elliptic curve configurations.
 
 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.
 
@@ -155,7 +155,8 @@ In LightPHE, the [Elliptic Curve ElGamal](https://sefiks.com/2018/08/21/elliptic
 forms = ["weierstrass", "edwards", "koblitz"]
 phe = LightPHE(
     algorithm_name="EllipticCurve-ElGamal",
-    form=forms[1],
+    form="edwards",
+    # curve="ed448", # optinally you can specify the curve for given form
 )
 ```
 
@@ -188,12 +189,16 @@ c4 = c1 + c2
 c5 = 3 * c1
 
 # perform element-wise multiplication between an encrypted embedding and plain embedding
-c6 = c1 * t3  # Encrypted-plaintext multiplication
+c6 = c1 * t3
+
+# encrypted dot product (likewise cosine similarity)
+c7 = c1 @ t3
 
 # proof of work
 assert np.allclose(cs.decrypt(c4), [a + b for a, b in zip(t1, t2)], rtol=1e-2)
 assert np.allclose(cs.decrypt(c5), [a * 3 for a in t1], rtol=1e-2)
 assert np.allclose(cs.decrypt(c6), [a * b for a, b in zip(t1, t3)], rtol=1e-2)
+assert np.allclose(cs.decrypt(c7)[0], sum([a * b for a, b in zip(t1, t3)]), rtol=1e-2)
 ```
 
 # Contributing

{lightphe-0.0.17 → lightphe-0.0.19}/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.19"
 
 
 class LightPHE:
@@ -53,6 +49,8 @@ class LightPHE:
         precision: int = 5,
         form: Optional[str] = None,
         curve: Optional[str] = None,
+        plaintext_limit: Optional[int] = None,
+        max_tries: int = 10000,
     ):
         """
         Build LightPHE class
@@ -61,7 +59,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 +71,14 @@ 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'.
+            max_tries (int): maximum attempts to generate keys. Default is 10000.
+                RSA, Benaloh, Naccache-Stern and Goldwasser-Micali algorithms
+                need multiple attempts to generate valid keys. Will be discarded
+                for other algorithms.
         """
         self.algorithm_name = algorithm_name
         self.precision = precision
@@ -90,6 +94,8 @@ class LightPHE:
             key_size=key_size,
             form=form,
             curve=curve,
+            plaintext_limit=plaintext_limit,
+            max_tries=max_tries,
         )
 
     def __build_cryptosystem(
@@ -99,6 +105,8 @@ class LightPHE:
         key_size: Optional[int] = None,
         form: Optional[str] = None,
         curve: Optional[str] = None,
+        plaintext_limit: Optional[int] = None,
+        max_tries: int = 10000,
     ) -> Union[
         RSA,
         ElGamal,
@@ -127,12 +135,18 @@ class LightPHE:
                  - ed25519, ed448 for edwards form
                  - secp256k1 for weierstrass form
                 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'.
+            max_tries (int): maximum attempts to generate keys. Default is 10000.
+                RSA, Benaloh, Naccache-Stern and Goldwasser-Micali algorithms
+                need multiple attempts to generate valid keys. Will be discarded
+                for other algorithms.
         Returns
             cryptosystem
         """
         # build cryptosystem
         if algorithm_name == Algorithm.RSA:
-            cs = RSA(keys=keys, key_size=key_size)
+            cs = RSA(keys=keys, key_size=key_size, max_tries=max_tries)
         elif algorithm_name == Algorithm.ElGamal:
             cs = ElGamal(keys=keys, key_size=key_size)
         elif algorithm_name == Algorithm.ExponentialElGamal:
@@ -148,11 +162,16 @@ 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,
+                max_tries=max_tries,
+            )
         elif algorithm_name == Algorithm.NaccacheStern:
-            cs = NaccacheStern(keys=keys, key_size=key_size)
+            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)
+            cs = GoldwasserMicali(keys=keys, key_size=key_size, max_tries=max_tries)
         else:
             raise ValueError(f"unimplemented algorithm - {algorithm_name}")
         return cs

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

@@ -15,19 +15,37 @@ 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,
+        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): 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.
+            max_tries (int): maximum attempts to generate keys.
+        """
+        self.keys = keys or self.generate_keys(
+            key_size=key_size or 1024,
+            plaintext_limit=plaintext_limit,
+            max_tries=max_tries,
+        )
         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 +67,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 +78,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 +106,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.19}/lightphe/cryptosystems/GoldwasserMicali.py

@@ -23,17 +23,29 @@ class GoldwasserMicali(Homomorphic):
     Ref: sefiks.com/2023/10/27/a-step-by-step-partially-homomorphic-encryption-example-with-goldwasser-micali-in-python/
     """
 
-    def __init__(self, keys: Optional[dict] = None, key_size: Optional[int] = None):
+    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): key size in bits
+            max_tries (int): maximum attempts to generate keys
         """
 
-        self.keys = keys or self.generate_keys(key_size or 1024)
+        self.keys = keys or self.generate_keys(
+            key_size=key_size or 1024, max_tries=max_tries
+        )
         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.19}/lightphe/cryptosystems/NaccacheStern.py

@@ -25,6 +25,7 @@ class NaccacheStern(Homomorphic):
         keys: Optional[dict] = None,
         key_size: Optional[int] = None,
         deterministic: bool = False,
+        max_tries: int = 10000,
     ):
         """
         Args:
@@ -34,9 +35,12 @@ class NaccacheStern(Homomorphic):
                 decryption requires to solve DLP.
             deterministic (boolean): deterministic or probabilistic version of
                 cryptosystem
+            max_tries (int): maximum attempts to generate keys
         """
         # Naccache-Stern requires to solve DLP in decryption, so small key is recommended
-        self.keys = keys or self.generate_keys(key_size or 1024)
+        self.keys = keys or self.generate_keys(
+            key_size=key_size or 1024, max_tries=max_tries
+        )
         self.plaintext_modulo = self.keys["public_key"]["sigma"]
         self.ciphertext_modulo = self.keys["public_key"]["n"]
         self.deterministic = deterministic

{lightphe-0.0.17 → lightphe-0.0.19}/lightphe/cryptosystems/RSA.py

@@ -14,7 +14,13 @@ class RSA(Homomorphic):
     Ref: https://sefiks.com/2023/03/06/a-step-by-step-partially-homomorphic-encryption-example-with-rsa-in-python/
     """
 
-    def __init__(self, keys: Optional[dict] = None, key_size: Optional[int] = None, encrypt_with_public=True):
+    def __init__(
+        self,
+        keys: Optional[dict] = None,
+        key_size: Optional[int] = None,
+        encrypt_with_public=True,
+        max_tries: int = 10000,
+    ):
         """
         Args:
             keys (dict): private - public key pair.
@@ -26,17 +32,25 @@ class RSA(Homomorphic):
                 one can decrypt it with your public (digital signatures).
                 Set this arg to True if you want to do encryption with public key e,
                 and do decryption with private key d.
+            max_tries (int): maximum attempts to generate keys.
         """
-        self.keys = keys or self.generate_keys(key_size or 1024)
+        self.keys = keys or self.generate_keys(
+            key_size=key_size or 1024, max_tries=max_tries
+        )
         self.plaintext_modulo = self.keys["public_key"]["n"]
         self.ciphertext_modulo = self.keys["public_key"]["n"]
         self.encrypt_with_public = encrypt_with_public
 
-    def generate_keys(self, key_size: int) -> dict:
+    def generate_keys(
+        self,
+        key_size: int,
+        max_tries: int = 10000,
+    ) -> dict:
         """
         Generate public and private keys of RSA cryptosystem
         Args:
             key_size (int): key size in bits
+            max_tries (int): maximum number of tries to generate keys
         Returns:
             keys (dict): having private_key and public_key keys
         """
@@ -44,33 +58,35 @@ class RSA(Homomorphic):
         keys["private_key"] = {}
         keys["public_key"] = {}
 
-        while True:
-            try:
-                # picking a prime modulus p and q
-                p = sympy.randprime(200, 2 ** int(key_size / 2) - 1)
-                q = sympy.randprime(200, 2 ** int(key_size / 2) - 1)
+        for _ in range(max_tries):
+            # picking a prime modulus p and q
+            p = sympy.randprime(2 ** (key_size // 2 - 300), 2 ** (key_size // 2) - 1)
+            q = sympy.randprime(2 ** (key_size // 2 - 300), 2 ** (key_size // 2) - 1)
 
-                n = p * q
-                phi = (p - 1) * (q - 1)
+            if p == q:
+                continue
 
-                # select public exponent e
-                while True:
-                    e = random.randint(1, phi - 1)
-                    if math.gcd(e, n) == 1:
-                        break
+            n = p * q
+            phi = (p - 1) * (q - 1)
 
-                d = pow(e, -1, phi)
-                break
-            except:
-                pass
-
-        keys["public_key"]["n"] = n
-        keys["public_key"]["e"] = e
-        keys["private_key"]["d"] = d
-        return keys
+            # select public exponent e
+            for _ in range(1000):  # try max 1000 random e
+                e = random.randint(2, phi - 1)
+                if math.gcd(e, phi) == 1:
+                    d = pow(e, -1, phi)
+                    return {
+                        "public_key": {"n": n, "e": e},
+                        "private_key": {"d": d},
+                    }
+        raise ValueError(f"Failed to generate RSA keys after {max_tries} tries")
 
     def generate_random_key(self) -> int:
-        pass
+        """
+        RSA does not require random key for encryption, still return one
+        Returns:
+            random key (int): one time random key for encryption
+        """
+        return random.randint(1, self.keys["public_key"]["n"] - 1)
 
     def encrypt(self, plaintext: int) -> int:
         """

{lightphe-0.0.17 → lightphe-0.0.19}/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.19}/lightphe.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: lightphe
-Version: 0.0.17
+Version: 0.0.19
 Summary: A Lightweight Partially Homomorphic Encryption Library for Python
 Home-page: https://github.com/serengil/LightPHE
 Author: Sefik Ilkin Serengil
@@ -129,7 +129,7 @@ assert cs.decrypt(c3) == m1 + m2
 assert cs.decrypt(c4) == k * m1
 ```
 
-On the other hand, if you adopt a multiplicatively homomorphic cryptosyste (e.g. RSA or ElGamal), you can multiply ciphertexts without revealing the private key or the plaintext.
+On the other hand, if you adopt a multiplicatively homomorphic cryptosystem (e.g. RSA or ElGamal), you can multiply ciphertexts without revealing the private key or the plaintext.
 
 ```python
 # build a multiplicatively homomorphic cryptosystem
@@ -152,7 +152,7 @@ assert cs.decrypt(c3) == m1 * m2
 
 ### Ciphertext Regeneration
 
-Similar to the most of additively homomorphic algorithms, Paillier lets you to regenerate ciphertext while you are not breaking its plaintext restoration. You may consider to do this re-generation many times to have stronger ciphertexts.
+The most of additively homomorphic algorithms allow you to regenerate ciphertext while you are not breaking its plaintext restoration. You may consider to do this re-generation many times to have stronger ciphertexts.
 
 ```python
 c1_prime = cs.regenerate_ciphertext(c1)
@@ -163,7 +163,7 @@ assert cs.decrypt(c1) == m1
 
 ### Elliptic Curve Cryptography
 
-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.
+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 (default), edwards and koblitz) and 100+ standard elliptic curve configurations.
 
 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.
 
@@ -171,7 +171,8 @@ In LightPHE, the [Elliptic Curve ElGamal](https://sefiks.com/2018/08/21/elliptic
 forms = ["weierstrass", "edwards", "koblitz"]
 phe = LightPHE(
     algorithm_name="EllipticCurve-ElGamal",
-    form=forms[1],
+    form="edwards",
+    # curve="ed448", # optinally you can specify the curve for given form
 )
 ```
 
@@ -204,12 +205,16 @@ c4 = c1 + c2
 c5 = 3 * c1
 
 # perform element-wise multiplication between an encrypted embedding and plain embedding
-c6 = c1 * t3  # Encrypted-plaintext multiplication
+c6 = c1 * t3
+
+# encrypted dot product (likewise cosine similarity)
+c7 = c1 @ t3
 
 # proof of work
 assert np.allclose(cs.decrypt(c4), [a + b for a, b in zip(t1, t2)], rtol=1e-2)
 assert np.allclose(cs.decrypt(c5), [a * 3 for a in t1], rtol=1e-2)
 assert np.allclose(cs.decrypt(c6), [a * b for a, b in zip(t1, t3)], rtol=1e-2)
+assert np.allclose(cs.decrypt(c7)[0], sum([a * b for a, b in zip(t1, t3)]), rtol=1e-2)
 ```
 
 # Contributing

{lightphe-0.0.17 → lightphe-0.0.19}/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.19}/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.19",
     author="Sefik Ilkin Serengil",
     author_email="serengil@gmail.com",
     description="A Lightweight Partially Homomorphic Encryption Library for Python",

lightphe-0.0.19/tests/test_large_keys.py

@@ -0,0 +1,77 @@
+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
+
+    Naccache-Stern | 1024 | 19.97 | 0.00 | 0.00 |0.06
+    """
+    algorithms = [
+        "Naccache-Stern",
+        "Goldwasser-Micali",
+        "Benaloh",
+    ]
+    key_sizes = [1024, 2048, 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}"
+            )