lightphe 0.0.18__tar.gz → 0.0.20__tar.gz

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: lightphe
-Version: 0.0.18
+Version: 0.0.20
 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.18 → lightphe-0.0.20}/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.18 → lightphe-0.0.20}/lightphe/__init__.py

@@ -34,7 +34,7 @@ from lightphe.cryptosystems.EllipticCurveElGamal import EllipticCurveElGamal
 
 logger = Logger(module="lightphe/__init__.py")
 
-VERSION = "0.0.18"
+VERSION = "0.0.20"
 
 
 class LightPHE:
@@ -50,6 +50,7 @@ class LightPHE:
         form: Optional[str] = None,
         curve: Optional[str] = None,
         plaintext_limit: Optional[int] = None,
+        max_tries: int = 10000,
     ):
         """
         Build LightPHE class
@@ -74,6 +75,10 @@ class LightPHE:
                 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 +95,7 @@ class LightPHE:
             form=form,
             curve=curve,
             plaintext_limit=plaintext_limit,
+            max_tries=max_tries,
         )
 
     def __build_cryptosystem(
@@ -100,6 +106,7 @@ class LightPHE:
         form: Optional[str] = None,
         curve: Optional[str] = None,
         plaintext_limit: Optional[int] = None,
+        max_tries: int = 10000,
     ) -> Union[
         RSA,
         ElGamal,
@@ -128,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:
@@ -149,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, plaintext_limit=plaintext_limit)
+            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.18 → lightphe-0.0.20}/lightphe/cryptosystems/Benaloh.py

@@ -20,6 +20,7 @@ class Benaloh(Homomorphic):
         keys: Optional[dict] = None,
         key_size: Optional[int] = None,
         plaintext_limit: Optional[int] = None,
+        max_tries: int = 10000,
     ):
         """
         Args:
@@ -29,9 +30,12 @@ class Benaloh(Homomorphic):
             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
+            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"]

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

@@ -23,15 +23,23 @@ 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"]
 
         # Plaintext can be any integer (even larger than n) because it is internally

{lightphe-0.0.18 → lightphe-0.0.20}/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.18 → lightphe-0.0.20}/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.18 → lightphe-0.0.20}/lightphe.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: lightphe
-Version: 0.0.18
+Version: 0.0.20
 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.18 → lightphe-0.0.20}/lightphe.egg-info/requires.txt

@@ -1,4 +1,3 @@
 sympy>=1.12
-pytest>=7.1.2
 tqdm
 lightecc

lightphe-0.0.20/requirements.txt

@@ -0,0 +1,3 @@
+sympy>=1.12
+tqdm
+lightecc

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

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

{lightphe-0.0.18 → lightphe-0.0.20}/tests/test_large_keys.py

@@ -22,14 +22,15 @@ def test_large_keys():
     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",
+        "Naccache-Stern",
+        "Goldwasser-Micali",
         "Benaloh",
     ]
-    # key_sizes = [1024, 2048, 3072, 7680]
-    key_sizes = [3072, 7680]
+    key_sizes = [1024, 2048, 3072, 7680]
 
     for key_size in key_sizes:
         for algorithm_name in algorithms:

lightphe-0.0.18/requirements.txt

@@ -1,4 +0,0 @@
-sympy>=1.12
-pytest>=7.1.2
-tqdm
-lightecc