lightphe 0.0.15__tar.gz → 0.0.16__tar.gz

{lightphe-0.0.15 → lightphe-0.0.16}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: lightphe
-Version: 0.0.15
+Version: 0.0.16
 Summary: A Lightweight Partially Homomorphic Encryption Library for Python
 Home-page: https://github.com/serengil/LightPHE
 Author: Sefik Ilkin Serengil
@@ -28,7 +28,7 @@ License-File: LICENSE
 [![YouTube](https://img.shields.io/:youtube-@sefiks-red.svg?style=flat&logo=youtube)](https://www.youtube.com/@sefiks?sub_confirmation=1)
 [![Twitter](https://img.shields.io/:follow-@serengil-blue.svg?style=flat&logo=x)](https://twitter.com/intent/user?screen_name=serengil)
 
-[![Support me on Patreon](https://img.shields.io/endpoint.svg?url=https%3A%2F%2Fshieldsio-patreon.vercel.app%2Fapi%3Fusername%3Dserengil%26type%3Dpatrons&style=flat)](https://www.patreon.com/serengil?repo=lightphe)
+[![Patreon](https://img.shields.io/:become-patron-f96854.svg?style=flat&logo=patreon)](https://www.patreon.com/serengil?repo=lightphe)
 [![GitHub Sponsors](https://img.shields.io/github/sponsors/serengil?logo=GitHub&color=lightgray)](https://github.com/sponsors/serengil)
 [![Buy Me a Coffee](https://img.shields.io/badge/-buy_me_a%C2%A0coffee-gray?logo=buy-me-a-coffee)](https://buymeacoffee.com/serengil)
 
@@ -262,7 +262,7 @@ One of the crucial factors that define the security level of an elliptic curve c
 
 Each curve in LightPHE has a specific order, which is carefully chosen to balance performance and security. By selecting an elliptic curve with a larger order, you increase the security of your cryptographic system, but this may come with a trade-off in computational efficiency. Therefore, choosing the appropriate curve order is a crucial decision based on your application’s security and performance requirements.
 
-See [`curves`](https://github.com/serengil/LightECC) page for a list of all supported forms, curves and their details.
+See [`curves`](https://github.com/serengil/LightECC#supported-curves) page for a list of all supported forms, curves and their details.
 
 ### Vector Embeddings and Tensors
 
@@ -379,6 +379,12 @@ calculated_similarity = cs.decrypt(encrypted_cosine_similarity)[0]
 assert abs(calculated_similarity - expected_similarity) < 1e-2
 ```
 
+## Security Concerns and Considerations
+
+While LightPHE enables encryption using public keys and supports homomorphic operations on encrypted data, it's important to understand a subtle but critical security implication of this approach. Since the it is homomorphic, the cloud (or any third-party processor) can perform computations without knowing the plaintext. However, a malicious actor can still encrypt arbitrary values and craft valid ciphertexts because encryption depends on your public key and it is publicly known. For example, even if a salary is encrypted, an attacker could encrypt 500 USD using your public key and update the encrypted salary with this forged ciphertext — without needing to know the original value.
+
+To mitigate this, we recommend combining LightPHE with digital signature schemes. By keeping a signed audit trail of update operations in a separate log table, you can detect and reject unauthorized changes, and even restore the original data in case of tampering. We suggest checking out [`LightDSA`](https://github.com/serengil/LightDSA), which provides a lightweight cryptographic interface similar to LightPHE and supports popular digital signature algorithms like RSA, DSA, ECDSA, and EdDSA.
+
 # Contributing
 
 All PRs are more than welcome! If you are planning to contribute a large patch, please create an issue first to get any upfront questions or design decisions out of the way first.
@@ -392,11 +398,11 @@ There are many ways to support a project - starring⭐️ the GitHub repo is jus
 You can also support this work on [Patreon](https://www.patreon.com/serengil?repo=lightphe), [GitHub Sponsors](https://github.com/sponsors/serengil) or [Buy Me a Coffee](https://buymeacoffee.com/serengil).
 
 <a href="https://www.patreon.com/serengil?repo=lightphe">
-<img src="https://raw.githubusercontent.com/serengil/LightPHE/master/icons/patreon.png" width="30%" height="30%">
+<img src="https://raw.githubusercontent.com/serengil/LightPHE/master/icons/patreon.png" width="30%">
 </a>
 
 <a href="https://buymeacoffee.com/serengil">
-<img src="https://raw.githubusercontent.com/serengil/LightPHE/master/icons/bmc-button.png" width="25%" height="25%">
+<img src="https://raw.githubusercontent.com/serengil/LightPHE/master/icons/bmc-button.png" width="25%">
 </a>
 
 Also, your company's logo will be shown on README on GitHub if you become sponsor in gold, silver or bronze tiers.

{lightphe-0.0.15 → lightphe-0.0.16}/README.md

@@ -12,7 +12,7 @@
 [![YouTube](https://img.shields.io/:youtube-@sefiks-red.svg?style=flat&logo=youtube)](https://www.youtube.com/@sefiks?sub_confirmation=1)
 [![Twitter](https://img.shields.io/:follow-@serengil-blue.svg?style=flat&logo=x)](https://twitter.com/intent/user?screen_name=serengil)
 
-[![Support me on Patreon](https://img.shields.io/endpoint.svg?url=https%3A%2F%2Fshieldsio-patreon.vercel.app%2Fapi%3Fusername%3Dserengil%26type%3Dpatrons&style=flat)](https://www.patreon.com/serengil?repo=lightphe)
+[![Patreon](https://img.shields.io/:become-patron-f96854.svg?style=flat&logo=patreon)](https://www.patreon.com/serengil?repo=lightphe)
 [![GitHub Sponsors](https://img.shields.io/github/sponsors/serengil?logo=GitHub&color=lightgray)](https://github.com/sponsors/serengil)
 [![Buy Me a Coffee](https://img.shields.io/badge/-buy_me_a%C2%A0coffee-gray?logo=buy-me-a-coffee)](https://buymeacoffee.com/serengil)
 
@@ -246,7 +246,7 @@ One of the crucial factors that define the security level of an elliptic curve c
 
 Each curve in LightPHE has a specific order, which is carefully chosen to balance performance and security. By selecting an elliptic curve with a larger order, you increase the security of your cryptographic system, but this may come with a trade-off in computational efficiency. Therefore, choosing the appropriate curve order is a crucial decision based on your application’s security and performance requirements.
 
-See [`curves`](https://github.com/serengil/LightECC) page for a list of all supported forms, curves and their details.
+See [`curves`](https://github.com/serengil/LightECC#supported-curves) page for a list of all supported forms, curves and their details.
 
 ### Vector Embeddings and Tensors
 
@@ -363,6 +363,12 @@ calculated_similarity = cs.decrypt(encrypted_cosine_similarity)[0]
 assert abs(calculated_similarity - expected_similarity) < 1e-2
 ```
 
+## Security Concerns and Considerations
+
+While LightPHE enables encryption using public keys and supports homomorphic operations on encrypted data, it's important to understand a subtle but critical security implication of this approach. Since the it is homomorphic, the cloud (or any third-party processor) can perform computations without knowing the plaintext. However, a malicious actor can still encrypt arbitrary values and craft valid ciphertexts because encryption depends on your public key and it is publicly known. For example, even if a salary is encrypted, an attacker could encrypt 500 USD using your public key and update the encrypted salary with this forged ciphertext — without needing to know the original value.
+
+To mitigate this, we recommend combining LightPHE with digital signature schemes. By keeping a signed audit trail of update operations in a separate log table, you can detect and reject unauthorized changes, and even restore the original data in case of tampering. We suggest checking out [`LightDSA`](https://github.com/serengil/LightDSA), which provides a lightweight cryptographic interface similar to LightPHE and supports popular digital signature algorithms like RSA, DSA, ECDSA, and EdDSA.
+
 # Contributing
 
 All PRs are more than welcome! If you are planning to contribute a large patch, please create an issue first to get any upfront questions or design decisions out of the way first.
@@ -376,11 +382,11 @@ There are many ways to support a project - starring⭐️ the GitHub repo is jus
 You can also support this work on [Patreon](https://www.patreon.com/serengil?repo=lightphe), [GitHub Sponsors](https://github.com/sponsors/serengil) or [Buy Me a Coffee](https://buymeacoffee.com/serengil).
 
 <a href="https://www.patreon.com/serengil?repo=lightphe">
-<img src="https://raw.githubusercontent.com/serengil/LightPHE/master/icons/patreon.png" width="30%" height="30%">
+<img src="https://raw.githubusercontent.com/serengil/LightPHE/master/icons/patreon.png" width="30%">
 </a>
 
 <a href="https://buymeacoffee.com/serengil">
-<img src="https://raw.githubusercontent.com/serengil/LightPHE/master/icons/bmc-button.png" width="25%" height="25%">
+<img src="https://raw.githubusercontent.com/serengil/LightPHE/master/icons/bmc-button.png" width="25%">
 </a>
 
 Also, your company's logo will be shown on README on GitHub if you become sponsor in gold, silver or bronze tiers.

{lightphe-0.0.15 → lightphe-0.0.16}/lightphe/__init__.py

@@ -38,7 +38,7 @@ from lightphe.cryptosystems.EllipticCurveElGamal import EllipticCurveElGamal
 
 logger = Logger(module="lightphe/__init__.py")
 
-VERSION = "0.0.15"
+VERSION = "0.0.16"
 
 
 class LightPHE:

{lightphe-0.0.15 → lightphe-0.0.16}/lightphe/cryptosystems/Benaloh.py

@@ -169,7 +169,7 @@ class Benaloh(Homomorphic):
         n = self.keys["public_key"]["n"]
         return (ciphertext1 * ciphertext2) % n
 
-    def multiply_by_contant(self, ciphertext: int, constant: int) -> int:
+    def multiply_by_constant(self, ciphertext: int, constant: int) -> int:
         """
         Multiply a ciphertext with a plain constant.
         Result of this must be equal to E(m1 * constant) where E(m1) = ciphertext

{lightphe-0.0.15 → lightphe-0.0.16}/lightphe/cryptosystems/DamgardJurik.py

@@ -125,7 +125,7 @@ class DamgardJurik(Homomorphic):
         modulo = pow(n, s + 1)
         return (ciphertext1 * ciphertext2) % modulo
 
-    def multiply_by_contant(self, ciphertext: int, constant: int) -> int:
+    def multiply_by_constant(self, ciphertext: int, constant: int) -> int:
         """
         Multiply a ciphertext by a known plain constant
         Result of this must be equal to E(m1 * m2), where E(m1) = ciphertext

{lightphe-0.0.15 → lightphe-0.0.16}/lightphe/cryptosystems/ElGamal.py

@@ -169,7 +169,7 @@ class ElGamal(Homomorphic):
         p = self.keys["public_key"]["p"]
         return (ciphertext1[0] * ciphertext2[0]) % p, (ciphertext1[1] * ciphertext2[1]) % p
 
-    def multiply_by_contant(self, ciphertext: tuple, constant: int) -> tuple:
+    def multiply_by_constant(self, ciphertext: tuple, constant: int) -> tuple:
         if self.exponential is False:
             raise ValueError("ElGamal is not supporting multiplying ciphertext by a known constant")
         p = self.keys["public_key"]["p"]

{lightphe-0.0.15 → lightphe-0.0.16}/lightphe/cryptosystems/EllipticCurveElGamal.py

@@ -168,7 +168,7 @@ class EllipticCurveElGamal(Homomorphic):
 
 
 
-    def multiply_by_contant(self, ciphertext: tuple, constant: int) -> tuple:
+    def multiply_by_constant(self, ciphertext: tuple, constant: int) -> tuple:
         """
         Multiply a ciphertext with a plain constant.
         Result of this must be equal to k x E(m1) = E(m1 * k)

{lightphe-0.0.15 → lightphe-0.0.16}/lightphe/cryptosystems/GoldwasserMicali.py

@@ -6,6 +6,7 @@ import math
 # 3rd party dependencies
 import sympy
 from sympy import jacobi_symbol
+from tqdm import tqdm
 
 # project dependencies
 from lightphe.models.Homomorphic import Homomorphic
@@ -29,51 +30,53 @@ class GoldwasserMicali(Homomorphic):
                 set this to None if you want to generate random keys.
             key_size (int): key size in bits
         """
-        # key size should be several hundred bits or more
-        self.keys = keys or self.generate_keys(key_size or 100)
+
+        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
         self.plaintext_modulo = self.keys["public_key"]["n"]
 
-    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 Goldwasser-Micali 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
         """
-        keys = {}
-        keys["private_key"] = {}
-        keys["public_key"] = {}
-
-        # picking a prime p
-        p = sympy.randprime(200, 2 ** int(key_size / 2) - 1)
-        assert isinstance(p, int)
-
-        # picking a prime q
-        q = sympy.randprime(200, 2 ** int(key_size / 2) - 1)
-        assert isinstance(q, int)
-
-        n = p * q
+        for attempt in tqdm(range(max_tries), disable=True):
+            # pick large random primes p and q
+            p = sympy.randprime(2 ** (key_size // 2 - 100), 2 ** (key_size // 2) - 1)
+            q = sympy.randprime(2 ** (key_size // 2 - 100), 2 ** (key_size // 2) - 1)
+
+            # to prevent factorizatin attacks, it is recommended that n should be
+            # several hundred bits or more
+            n = p * q
+
+            # find quadratic non-residue x
+            for _ in range(1000):  # try max 1000 random x
+                x = random.randint(2, n - 1)
+                if math.gcd(x, n) != 1:
+                    continue
+                if jacobi_symbol(x, p) == -1 and jacobi_symbol(x, q) == -1:
+                    break
+            else:
+                # # If no suitable x is found after 1000 tries, discard the current p–q pair and retry
+                continue
 
-        # find non-residue x
-        while True:
-            x = random.randint(1, n - 1)
-            if (
-                math.gcd(x, n) == 1
-                and jacobi_symbol(x, p) == -1
-                and jacobi_symbol(x, q) == -1
-            ):
-                break
+            keys = {
+                "public_key": {"n": n, "x": x},
+                "private_key": {"p": p, "q": q},
+            }
 
-        keys["public_key"]["n"] = n
-        keys["public_key"]["x"] = x
+            logger.debug(
+                f"Goldwasser-Micali keys generated after {attempt+1} attempts, n bits: {n.bit_length()}"
+            )
 
-        keys["private_key"]["p"] = p
-        keys["private_key"]["q"] = q
+            return keys
 
-        return keys
+        raise RuntimeError(f"Failed to generate keys after {max_tries} attempts")
 
     def generate_random_key(self) -> int:
         """

{lightphe-0.0.15 → lightphe-0.0.16}/lightphe/cryptosystems/NaccacheStern.py

@@ -3,12 +3,13 @@ from typing import Optional
 import math
 import sympy
 from sympy.ntheory.modular import solve_congruence
+from tqdm import tqdm
 from lightphe.models.Homomorphic import Homomorphic
 from lightphe.commons.logger import Logger
 
 logger = Logger(module="lightphe/cryptosystems/NaccacheStern.py")
 
-# pylint: disable=simplifiable-if-expression, consider-using-enumerate
+# pylint: disable=simplifiable-if-expression, consider-using-enumerate, pointless-string-statement
 
 
 class NaccacheStern(Homomorphic):
@@ -19,7 +20,12 @@ class NaccacheStern(Homomorphic):
     Original paper: https://dl.acm.org/doi/pdf/10.1145/288090.288106
     """
 
-    def __init__(self, keys: Optional[dict] = None, key_size: Optional[int] = None, deterministic: bool = False):
+    def __init__(
+        self,
+        keys: Optional[dict] = None,
+        key_size: Optional[int] = None,
+        deterministic: bool = False,
+    ):
         """
         Args:
             keys (dict): private - public key pair.
@@ -30,26 +36,24 @@ class NaccacheStern(Homomorphic):
                 cryptosystem
         """
         # Naccache-Stern requires to solve DLP in decryption, so small key is recommended
-        self.keys = keys or self.generate_keys(key_size or 37)
+        self.keys = keys or self.generate_keys(key_size or 1024)
         self.plaintext_modulo = self.keys["public_key"]["sigma"]
         self.ciphertext_modulo = self.keys["public_key"]["n"]
         self.deterministic = deterministic
 
-    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 Naccache-Stern cryptosystem
         Args:
-            key_size (int): key size in bits
+            key_size (int): key size in bits (≥1024 recommended)
+            max_tries (int): maximum attempts to generate keys
         Returns:
-            keys (dict): having private_key and public_key keys
+            keys (dict): containing 'private_key' and 'public_key'
         """
-        keys = {}
-        keys["private_key"] = {}
-        keys["public_key"] = {}
-
-        # pick a family of small primes. the largest one is 10-bits
-        # TODO: do something generic instead of constant primes
-        prime_set = [3, 5, 7, 11, 13, 17]
+        # Small prime set (the largest one is 10-bits)
+        # Using a smaller prime_set to make key generation feasible for large key sizes
+        # prime_set = [3, 5, 7, 11, 13, 17]
+        prime_set = [3, 5, 7, 11]
         k = len(prime_set)
 
         if all(sympy.isprime(prime) is True for prime in prime_set) is False:
@@ -58,24 +62,30 @@ class NaccacheStern(Homomorphic):
         # divide the set in half and find products of primes
         u = 1
         v = 1
-
         for i, prime in enumerate(prime_set):
-            if i < len(prime_set) / 2:
-                u = u * prime
+            if i < k // 2:
+                u *= prime
             else:
-                v = v * prime
+                v *= prime
 
         # product of all primes
         sigma = u * v
 
-        # pick large prime numbers
-        while True:
-            a = sympy.randprime(200, 2 ** int(key_size / 2) - 1)
-            b = sympy.randprime(100, a)
+        for attempt in tqdm(
+            range(max_tries),
+            desc="Attempting Naccache-Stern key generation",
+            disable=True,
+        ):
+            # Generate large random primes a and b
+            a = sympy.randprime(2 ** (key_size // 2 - 300), 2 ** (key_size // 2) - 1)
+            b = sympy.randprime(2 ** (key_size // 2 - 300), 2 ** (key_size // 2) - 1)
 
             # calculate two primes from chosen ones
-            p = (2 * a * u) + 1
-            q = (2 * b * v) + 1
+            p = 2 * a * u + 1
+            q = 2 * b * v + 1
+
+            if not (sympy.isprime(p) and sympy.isprime(q)):
+                continue
 
             # recommended n is 768 bits
             n = p * q
@@ -89,83 +99,82 @@ class NaccacheStern(Homomorphic):
                 logger.debug("canceled because sigma and phi/sigma are not coprime")
                 continue
 
-            p_conditions = []
-            for i in range(0, int(k / 2)):
-                pi = prime_set[i]
-                if (
-                    (p - 1) % pi == 0
-                    and math.gcd(pi, int((p - 1) / pi)) == 1
-                    and math.gcd(pi, q - 1) == 1
-                ):
-                    p_conditions.append(1)
-                else:
-                    p_conditions.append(0)
-            p_satisfied = True if len(p_conditions) == sum(p_conditions) else False
-            if p_satisfied is False:
-                logger.debug("canceled because p_conditions are not satisfied")
-                continue
+            # p_conditions and q_conditions check omitted for practical large-key generation
+            if key_size < 40:
+                p_conditions = []
+                for i in range(0, int(k / 2)):
+                    pi = prime_set[i]
+                    if (
+                        (p - 1) % pi == 0
+                        and math.gcd(pi, int((p - 1) / pi)) == 1
+                        and math.gcd(pi, q - 1) == 1
+                    ):
+                        p_conditions.append(1)
+                    else:
+                        p_conditions.append(0)
+                p_satisfied = True if len(p_conditions) == sum(p_conditions) else False
+                if p_satisfied is False:
+                    logger.debug("canceled because p_conditions are not satisfied")
+                    continue
 
-            q_conditions = []
-            for i in range(int(k / 2), k):
-                pi = prime_set[i]
-                if (
-                    (q - 1) % pi == 0
-                    and math.gcd(pi, int((q - 1) / pi)) == 1
-                    and math.gcd(pi, p - 1)
-                ):
-                    q_conditions.append(1)
-                else:
-                    q_conditions.append(0)
-
-            q_satisfied = True if len(q_conditions) == sum(q_conditions) else False
-            if q_satisfied is False:
-                logger.debug("canceled because q_conditions are not satisfied")
-                continue
+                q_conditions = []
+                for i in range(int(k / 2), k):
+                    pi = prime_set[i]
+                    if (
+                        (q - 1) % pi == 0
+                        and math.gcd(pi, int((q - 1) / pi)) == 1
+                        and math.gcd(pi, p - 1)
+                    ):
+                        q_conditions.append(1)
+                    else:
+                        q_conditions.append(0)
+
+                q_satisfied = True if len(q_conditions) == sum(q_conditions) else False
+                if q_satisfied is False:
+                    logger.debug("canceled because q_conditions are not satisfied")
+                    continue
 
-            # p and q must be primes
-            if not (sympy.isprime(p) and sympy.isprime(q)):
-                continue
+            # Choose generator g
+            for _ in range(1000):  # try max 1000 random g
+                g = random.randint(2, n - 1)
 
-            # choose a generator g
-            g = random.randint(2, n)
-            # it must be co-prime to n
-            if math.gcd(g, n) != 1:
-                logger.debug("canceled becuase g is not co-prime with ne")
-                continue
-            # guarantee it is not pi-th power.
-            for pi in prime_set:
-                logger.debug("canceled because g is a pi-th power")
-                if pow(g, int(phi / pi), n) == 1:
+                # it must be co-prime to n
+                if math.gcd(g, n) != 1:
                     continue
 
-            # the order of g modulo n must be phi/4
-            if pow(g, int(phi / 4), n) != 1:
-                continue
-
-            # check decryption is guaranteed similar to benaloh
-            # ps: this is not mentioned in the original paper
-            is_decryption_guaranteed = True
-            for pi in prime_set:
-                prime_factors = sympy.factorint(pi).keys()
-                for prime_factor in prime_factors:
-                    if pow(g, int(phi / prime_factor), n) == 1:
-                        is_decryption_guaranteed = False
-            if is_decryption_guaranteed is True:
+                # guarantee it is not pi-th power.
+                if any(pow(g, phi // pi, n) == 1 for pi in prime_set):
+                    continue
                 break
+            else:
+                continue  # if no g found, retry
 
-        logger.debug(f"n bits is {len(bin(n)[2:])}")
-
-        keys["public_key"]["g"] = g
-        keys["public_key"]["n"] = n
-        # sigma can optionally be secret in deterministic version
-        keys["public_key"]["sigma"] = sigma
+            # Original phi/4 order check omitted for practical large-key generation
+            if key_size < 40:
+                if pow(g, int(phi / 4), n) != 1:
+                    continue
 
-        keys["private_key"]["p"] = p
-        keys["private_key"]["q"] = q
-        keys["private_key"]["phi"] = phi
-        keys["private_key"]["prime_set"] = prime_set
+            # Success
+            keys = {
+                "public_key": {"n": n, "g": g, "sigma": sigma},
+                "private_key": {
+                    "a": a,
+                    "b": b,
+                    "p": p,
+                    "q": q,
+                    "phi": phi,
+                    "prime_set": prime_set,
+                },
+            }
+            logger.debug(
+                f"Keys generated after {attempt+1} attempts, n bits: {n.bit_length()}"
+            )
+            return keys
 
-        return keys
+        raise RuntimeError(
+            f"Failed to generate Naccache-Stern keys after {max_tries} attempts."
+            "Try to rerun or decrease key size."
+        )
 
     def generate_random_key(self) -> int:
         """
@@ -218,12 +227,12 @@ class NaccacheStern(Homomorphic):
 
         remainders = []
         for i, prime in enumerate(prime_set):
-            ci = pow(ciphertext, int(phi / prime), n)
+            ci = pow(ciphertext, int(phi // prime), n)
             logger.debug(f"c_{i} = {ci}")
 
             j = 0
             while True:
-                if ci == pow(g, int((j * phi) / prime), n):
+                if ci == pow(g, int((j * phi) // prime), n):
                     logger.debug(f"m_{i} = {j}")
                     remainders.append(j)
                     break
@@ -257,7 +266,7 @@ class NaccacheStern(Homomorphic):
         """
         return (ciphertext1 * ciphertext2) % self.ciphertext_modulo
 
-    def multiply_by_contant(self, ciphertext: int, constant: int) -> int:
+    def multiply_by_constant(self, ciphertext: int, constant: int) -> int:
         """
         Multiply a ciphertext with a plain constant.
         Result of this must be equal to E(m1 * constant) where E(m1) = ciphertext

{lightphe-0.0.15 → lightphe-0.0.16}/lightphe/cryptosystems/OkamotoUchiyama.py

@@ -127,7 +127,7 @@ class OkamotoUchiyama(Homomorphic):
         n = self.keys["public_key"]["n"]
         return (ciphertext1 * ciphertext2) % n
 
-    def multiply_by_contant(self, ciphertext: int, constant: int) -> int:
+    def multiply_by_constant(self, ciphertext: int, constant: int) -> int:
         """
         Multiply a ciphertext with a plain constant.
         Result of this must be equal to E(m1 * constant) where E(m1) = ciphertext

{lightphe-0.0.15 → lightphe-0.0.16}/lightphe/cryptosystems/Paillier.py

@@ -112,7 +112,7 @@ class Paillier(Homomorphic):
         n = self.keys["public_key"]["n"]
         return (ciphertext1 * ciphertext2) % (n * n)
 
-    def multiply_by_contant(self, ciphertext: int, constant: int) -> int:
+    def multiply_by_constant(self, ciphertext: int, constant: int) -> int:
         """
         Multiply a ciphertext with a plain constant.
         Result of this must be equal to E(m1 * m2) where E(m1) = ciphertext

{lightphe-0.0.15 → lightphe-0.0.16}/lightphe/models/Ciphertext.py

@@ -95,12 +95,12 @@ class Ciphertext:
             # Handle multiplication with another EncryptedObject
             result = self.cs.multiply(ciphertext1=self.value, ciphertext2=other.value)
         elif isinstance(other, int):
-            result = self.cs.multiply_by_contant(ciphertext=self.value, constant=other)
+            result = self.cs.multiply_by_constant(ciphertext=self.value, constant=other)
         elif isinstance(other, float):
             constant = phe_utils.normalize_input(
                 value=other, modulo=self.cs.plaintext_modulo
             )
-            result = self.cs.multiply_by_contant(
+            result = self.cs.multiply_by_constant(
                 ciphertext=self.value, constant=constant
             )
         else:

{lightphe-0.0.15 → lightphe-0.0.16}/lightphe/models/Homomorphic.py

@@ -14,7 +14,9 @@ class Homomorphic(ABC):
     ciphertext_modulo: int
 
     @abstractmethod
-    def generate_keys(self, key_size: int, s: Optional[int] = None) -> dict:
+    def generate_keys(
+        self, key_size: int, s: Optional[int] = None, max_retries: Optional[int] = None
+    ) -> dict:
         pass
 
     @abstractmethod
@@ -34,18 +36,28 @@ class Homomorphic(ABC):
     def add(
         self, ciphertext1: Union[int, tuple, list], ciphertext2: Union[int, tuple, list]
     ) -> Union[int, tuple, list]:
-        raise ValueError(f"{self.get_algorithm_name()} is not homomorphic with respect to the addition")
+        raise ValueError(
+            f"{self.get_algorithm_name()} is not homomorphic with respect to the addition"
+        )
 
     def multiply(
         self, ciphertext1: Union[int, tuple, list], ciphertext2: Union[int, tuple, list]
     ) -> Union[int, tuple]:
-        raise ValueError(f"{self.get_algorithm_name()} is not homomorphic with respect to the multiplication")
+        raise ValueError(
+            f"{self.get_algorithm_name()} is not homomorphic with respect to the multiplication"
+        )
 
     def xor(self, ciphertext1: list, ciphertext2: list) -> list:
-        raise ValueError(f"{self.get_algorithm_name()} is not homomorphic with respect to the exclusive or")
+        raise ValueError(
+            f"{self.get_algorithm_name()} is not homomorphic with respect to the exclusive or"
+        )
 
-    def multiply_by_contant(self, ciphertext: Union[int, tuple, list], constant: int) -> int:
-        raise ValueError(f"{self.get_algorithm_name()} is not supporting multiplying ciphertext by a known constant")
+    def multiply_by_constant(
+        self, ciphertext: Union[int, tuple, list], constant: int
+    ) -> int:
+        raise ValueError(
+            f"{self.get_algorithm_name()} is not supporting multiplying ciphertext by a known constant"
+        )
 
     def reencrypt(self, ciphertext: Union[int, tuple, list]) -> Union[int, tuple, list]:
         raise ValueError(f"{self.get_algorithm_name()} does not support re-encryption")
@@ -53,5 +65,7 @@ class Homomorphic(ABC):
     def get_algorithm_name(self) -> str:
         class_name = self.__class__.__name__
         algorithm_name = getattr(Algorithm, class_name, None)
-        assert isinstance(algorithm_name, str), f"Algorithm name for {class_name} is not defined"
+        assert isinstance(
+            algorithm_name, str
+        ), f"Algorithm name for {class_name} is not defined"
         return algorithm_name

{lightphe-0.0.15 → lightphe-0.0.16}/lightphe/models/Tensor.py

@@ -268,10 +268,10 @@ class EncryptedTensor:
 
             fractions = []
             for alpha_tensor in self.fractions:
-                dividend = self.cs.multiply_by_contant(
+                dividend = self.cs.multiply_by_constant(
                     ciphertext=alpha_tensor.dividend, constant=other
                 )
-                abs_dividend = self.cs.multiply_by_contant(
+                abs_dividend = self.cs.multiply_by_constant(
                     ciphertext=alpha_tensor.abs_dividend, constant=other
                 )
                 # notice that divisor is alpha tensor's divisor instead of addition

{lightphe-0.0.15 → lightphe-0.0.16}/lightphe.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: lightphe
-Version: 0.0.15
+Version: 0.0.16
 Summary: A Lightweight Partially Homomorphic Encryption Library for Python
 Home-page: https://github.com/serengil/LightPHE
 Author: Sefik Ilkin Serengil
@@ -28,7 +28,7 @@ License-File: LICENSE
 [![YouTube](https://img.shields.io/:youtube-@sefiks-red.svg?style=flat&logo=youtube)](https://www.youtube.com/@sefiks?sub_confirmation=1)
 [![Twitter](https://img.shields.io/:follow-@serengil-blue.svg?style=flat&logo=x)](https://twitter.com/intent/user?screen_name=serengil)
 
-[![Support me on Patreon](https://img.shields.io/endpoint.svg?url=https%3A%2F%2Fshieldsio-patreon.vercel.app%2Fapi%3Fusername%3Dserengil%26type%3Dpatrons&style=flat)](https://www.patreon.com/serengil?repo=lightphe)
+[![Patreon](https://img.shields.io/:become-patron-f96854.svg?style=flat&logo=patreon)](https://www.patreon.com/serengil?repo=lightphe)
 [![GitHub Sponsors](https://img.shields.io/github/sponsors/serengil?logo=GitHub&color=lightgray)](https://github.com/sponsors/serengil)
 [![Buy Me a Coffee](https://img.shields.io/badge/-buy_me_a%C2%A0coffee-gray?logo=buy-me-a-coffee)](https://buymeacoffee.com/serengil)
 
@@ -262,7 +262,7 @@ One of the crucial factors that define the security level of an elliptic curve c
 
 Each curve in LightPHE has a specific order, which is carefully chosen to balance performance and security. By selecting an elliptic curve with a larger order, you increase the security of your cryptographic system, but this may come with a trade-off in computational efficiency. Therefore, choosing the appropriate curve order is a crucial decision based on your application’s security and performance requirements.
 
-See [`curves`](https://github.com/serengil/LightECC) page for a list of all supported forms, curves and their details.
+See [`curves`](https://github.com/serengil/LightECC#supported-curves) page for a list of all supported forms, curves and their details.
 
 ### Vector Embeddings and Tensors
 
@@ -379,6 +379,12 @@ calculated_similarity = cs.decrypt(encrypted_cosine_similarity)[0]
 assert abs(calculated_similarity - expected_similarity) < 1e-2
 ```
 
+## Security Concerns and Considerations
+
+While LightPHE enables encryption using public keys and supports homomorphic operations on encrypted data, it's important to understand a subtle but critical security implication of this approach. Since the it is homomorphic, the cloud (or any third-party processor) can perform computations without knowing the plaintext. However, a malicious actor can still encrypt arbitrary values and craft valid ciphertexts because encryption depends on your public key and it is publicly known. For example, even if a salary is encrypted, an attacker could encrypt 500 USD using your public key and update the encrypted salary with this forged ciphertext — without needing to know the original value.
+
+To mitigate this, we recommend combining LightPHE with digital signature schemes. By keeping a signed audit trail of update operations in a separate log table, you can detect and reject unauthorized changes, and even restore the original data in case of tampering. We suggest checking out [`LightDSA`](https://github.com/serengil/LightDSA), which provides a lightweight cryptographic interface similar to LightPHE and supports popular digital signature algorithms like RSA, DSA, ECDSA, and EdDSA.
+
 # Contributing
 
 All PRs are more than welcome! If you are planning to contribute a large patch, please create an issue first to get any upfront questions or design decisions out of the way first.
@@ -392,11 +398,11 @@ There are many ways to support a project - starring⭐️ the GitHub repo is jus
 You can also support this work on [Patreon](https://www.patreon.com/serengil?repo=lightphe), [GitHub Sponsors](https://github.com/sponsors/serengil) or [Buy Me a Coffee](https://buymeacoffee.com/serengil).
 
 <a href="https://www.patreon.com/serengil?repo=lightphe">
-<img src="https://raw.githubusercontent.com/serengil/LightPHE/master/icons/patreon.png" width="30%" height="30%">
+<img src="https://raw.githubusercontent.com/serengil/LightPHE/master/icons/patreon.png" width="30%">
 </a>
 
 <a href="https://buymeacoffee.com/serengil">
-<img src="https://raw.githubusercontent.com/serengil/LightPHE/master/icons/bmc-button.png" width="25%" height="25%">
+<img src="https://raw.githubusercontent.com/serengil/LightPHE/master/icons/bmc-button.png" width="25%">
 </a>
 
 Also, your company's logo will be shown on README on GitHub if you become sponsor in gold, silver or bronze tiers.

lightphe-0.0.16/lightphe.egg-info/requires.txt

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

lightphe-0.0.16/requirements.txt

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

{lightphe-0.0.15 → lightphe-0.0.16}/setup.py

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

{lightphe-0.0.15 → lightphe-0.0.16}/tests/test_benaloh.py

@@ -16,7 +16,7 @@ def test_benaloh():
 
     # supported homomorphic operations
     assert bn.decrypt(bn.add(c1, c2)) == (m1 + m2) % bn.plaintext_modulo
-    assert bn.decrypt(bn.multiply_by_contant(c1, m2)) == (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):

{lightphe-0.0.15 → lightphe-0.0.16}/tests/test_damgard.py

@@ -16,7 +16,7 @@ def test_damgardjurik():
 
     # homomorphic operations
     assert dg.decrypt(dg.add(c1, c2)) == (m1 + m2) % dg.plaintext_modulo
-    assert dg.decrypt(dg.multiply_by_contant(c1, m2)) == (m1 * m2) % dg.plaintext_modulo
+    assert dg.decrypt(dg.multiply_by_constant(c1, m2)) == (m1 * m2) % dg.plaintext_modulo
 
     # unsupported homomorphic operations
     with pytest.raises(ValueError):

{lightphe-0.0.15 → lightphe-0.0.16}/tests/test_elgamal.py

@@ -26,7 +26,7 @@ def test_elgamal():
         eg.xor(c1, c2)
 
     with pytest.raises(ValueError):
-        eg.multiply_by_contant(c1, m2)
+        eg.multiply_by_constant(c1, m2)
 
     # re-encryption
     c1_prime = eg.reencrypt(c1)
@@ -54,7 +54,7 @@ def test_exponential_elgamal():
     # homomorphic operations
     assert additive_eg.decrypt(c3) == (m1 + m2) % additive_eg.plaintext_modulo
     assert (
-        additive_eg.decrypt(additive_eg.multiply_by_contant(c1, m2))
+        additive_eg.decrypt(additive_eg.multiply_by_constant(c1, m2))
         == (m1 * m2) % additive_eg.plaintext_modulo
     )
 

{lightphe-0.0.15 → lightphe-0.0.16}/tests/test_ellipticcurveelgamal.py

@@ -73,7 +73,7 @@ def __test_elliptic_curve_elgamal():
 
             # homomorphic operations
             c3 = cs.add(c1, c2)
-            c4 = cs.multiply_by_contant(c1, m2)
+            c4 = cs.multiply_by_constant(c1, m2)
 
             assert cs.decrypt(c3) == m1 + m2
             assert cs.decrypt(c4) == m1 * m2

{lightphe-0.0.15 → lightphe-0.0.16}/tests/test_goldwasser.py

@@ -8,6 +8,8 @@ logger = Logger(module="tests/test_goldwasser.py")
 def test_goldwasser():
     cs = GoldwasserMicali()
 
+    security_level = cs.keys["public_key"]["n"].bit_length()
+
     m1 = 17
     m2 = 27
 
@@ -29,9 +31,11 @@ def test_goldwasser():
         cs.add(c1, c2)
 
     with pytest.raises(ValueError):
-        cs.multiply_by_contant(c1, c2)
+        cs.multiply_by_constant(c1, c2)
 
-    logger.info("✅ Goldwasser-Micali test succeeded")
+    logger.info(
+        f"✅ Goldwasser-Micali test succeeded ({security_level} bit security level)"
+    )
 
 
 def test_api():
@@ -39,6 +43,8 @@ def test_api():
 
     cs = LightPHE(algorithm_name="Goldwasser-Micali")
 
+    security_level = cs.cs.keys["public_key"]["n"].bit_length()
+
     # try different bit size messages
     ms = [(17, 21), (117, 23), (23, 117), (1117, 23), (12, 1118)]
 
@@ -63,5 +69,6 @@ def test_api():
             _ = 5 * c1
 
         logger.info(
-            f"✅ Goldwasser-Micali api test succeeded for {m1.bit_length()}&{m2.bit_length()} bit plaintexts"
+            f"✅ Goldwasser-Micali api test succeeded for {m1.bit_length()}&{m2.bit_length()} bit plaintexts "
+            f"({security_level} bit security level)"
         )

{lightphe-0.0.15 → lightphe-0.0.16}/tests/test_keys.py

@@ -24,7 +24,12 @@ def test_key_restoration():
     for algorithm_name in algorithms:
         private_key_file = f"/tmp/{algorithm_name}_secret.json"
         public_key_file = f"/tmp/{algorithm_name}_public.json"
-        onprem_cs = LightPHE(algorithm_name=algorithm_name)
+
+        # unfortunately Naccache-Stern key generation isn't guaranteed to be completed
+        if algorithm_name == "Naccache-Stern":
+            onprem_cs = LightPHE(algorithm_name=algorithm_name, key_size=37)
+        else:
+            onprem_cs = LightPHE(algorithm_name=algorithm_name)
         onprem_cs.export_keys(private_key_file)
         onprem_cs.export_keys(public_key_file, public=True)
         del onprem_cs
@@ -57,4 +62,4 @@ def test_key_restoration():
             assert onprem_cs.decrypt(c3) == m1 + m2
             assert onprem_cs.decrypt(c4) == k * m1
 
-        logger.info(f"✅ Key restoration tesst succeeded for {algorithm_name}")
+        logger.info(f"✅ Key restoration test succeeded for {algorithm_name}")

lightphe-0.0.16/tests/test_naccache.py

@@ -0,0 +1,203 @@
+import time
+import pytest
+from lightphe.cryptosystems.NaccacheStern import NaccacheStern
+from lightphe.commons.logger import Logger
+
+logger = Logger(module="tests/test_naccache.py")
+
+
+def test_naccache_on_plaintexts():
+    cs = NaccacheStern(key_size=37, deterministic=False)
+
+    m1 = 17
+    m2 = 21
+
+    c1 = cs.encrypt(m1)
+    c2 = cs.encrypt(m2)
+
+    assert cs.decrypt(c1) == m1 % cs.plaintext_modulo
+    assert cs.decrypt(c2) == m2 % cs.plaintext_modulo
+
+    # homomorphic operations
+    assert cs.decrypt(cs.add(c1, c2)) == (m1 + m2) % cs.plaintext_modulo
+    assert (
+        cs.decrypt(cs.multiply_by_constant(c2, m1)) == (m1 * m2) % cs.plaintext_modulo
+    )
+
+    # unsupported operations
+    with pytest.raises(ValueError):
+        cs.multiply(c1, c2)
+
+    with pytest.raises(ValueError):
+        cs.xor(c1, c2)
+
+    # re-encryption
+    c1_prime = cs.reencrypt(c1)
+    assert c1_prime != c1
+    assert cs.decrypt(c1_prime) == m1 % cs.plaintext_modulo
+    logger.info("✅ Probabilistic Naccache-Stern test succeeded")
+
+
+def test_deterministic_version():
+    cs = NaccacheStern(deterministic=True, key_size=37)
+
+    m1 = 17
+    m2 = 21
+
+    c1 = cs.encrypt(m1)
+    c2 = cs.encrypt(m2)
+
+    assert cs.decrypt(c1) == m1 % cs.plaintext_modulo
+    assert cs.decrypt(c2) == m2 % cs.plaintext_modulo
+
+    # homomorphic operations
+    assert cs.decrypt(cs.add(c1, c2)) == (m1 + m2) % cs.plaintext_modulo
+    assert (
+        cs.decrypt(cs.multiply_by_constant(c2, m1)) == (m1 * m2) % cs.plaintext_modulo
+    )
+
+    # unsupported operations
+    with pytest.raises(ValueError):
+        cs.multiply(c1, c2)
+
+    with pytest.raises(ValueError):
+        cs.xor(c1, c2)
+
+    with pytest.raises(ValueError):
+        cs.reencrypt(c1)
+
+    logger.info("✅ Deterministic Naccache-Stern test succeeded")
+
+
+def test_predefined_keys():
+    """
+    Key generation of Naccache-Stern is probabilistic and may take time.
+        and may not succeed sometimes. Test encrypt, decrypt and homomorphic
+        operations performances with predefined keys.
+    """
+    keys = {
+        "public_key": {
+            "n": 75275183223356977395233015128636801841182684353869611205877871399639096259927846711964449336873721703958210179653876541687516247046310691985977881277598653839478670263258301833023097636036737220721033604997817044724812266620826468829212603338614968953684914579782761554925497589591101127424868060977977362624693729,
+            "g": 2322858651861384064537514431822509724460178869240342120700966005387085547272373554253264326744794826709642720143603083090045603237528622393527254537059946505389885957837759097286992580665451178640443489482838164247603492906332153298019557819758033383394570549848334276102748452532710144646257390863266986629778942,
+            "sigma": 255255,
+        },
+        "private_key": {
+            "a": 11597041531885171702428009785553891872754255798746286340205448513302430749967682685453809973100036260110796582178813477436613205882229456042479325870287379,
+            "b": 6357265649357031680615244845679689252112451833267362870520093680285536565908774220658104716644696735431871010152670595233003071273441498122136618828384989,
+            "p": 2435378721695886057509882054966317293278393717736720131443144187793510457493213363945300094351007614623267282257550830261688773235268185768920658432760349591,
+            "q": 30909025587173888031151320439694649143770740813345918276468695473548278783448460260839705132326515527669756851362284434022860932531472563869828240743607816519,
+            "phi": 75275183223356977395233015128636801841182684353869611205877871399639096259927846711964449336873721703958210179653876541687516247046310691985977881277598653806134265954388527744361895141375770783671899073915178636812972605279037227887538978553609742276161772286758627935090233305041395360684118422229078186256527620,
+            "prime_set": [3, 5, 7, 11, 13, 17],
+        },
+    }
+
+    from lightphe import LightPHE
+
+    cs = LightPHE(algorithm_name="Naccache-Stern", keys=keys)
+
+    security_level = cs.cs.keys["public_key"]["n"].bit_length()
+
+    logger.info(
+        f"Naccache-Stern cs built with {security_level} bits key. Recommended >= 768."
+    )
+
+    m1 = 17
+    m2 = 21
+
+    tic = time.time()
+    c1 = cs.encrypt(plaintext=m1)
+    c2 = cs.encrypt(plaintext=m2)
+    toc = time.time()
+    logger.info(f"Naccache-Stern encryption time: {(toc - tic)/2:.4f} seconds")
+
+    # homomorphic addition
+    tic = time.time()
+    assert cs.decrypt(c1 + c2) == m1 + m2
+    toc = time.time()
+    logger.info(f"Naccache-Stern homomorphic addition time: {(toc - tic):.4f} seconds")
+
+    # homomorphic scalar multiplication
+    tic = time.time()
+    c1_times_m2 = c1 * m2
+    c2_times_m1 = c2 * m1
+    m2_times_c1 = m2 * c1
+    m1_times_c2 = m1 * c2
+    toc = time.time()
+    logger.info(
+        f"Naccache-Stern homomorphic scalar multiplication time: {(toc - tic)/4:.4f} seconds"
+    )
+
+    assert cs.decrypt(c1_times_m2) == m1 * m2
+    assert cs.decrypt(c2_times_m1) == m1 * m2
+    assert cs.decrypt(m2_times_c1) == m1 * m2
+    assert cs.decrypt(m1_times_c2) == m1 * m2
+
+    # unsupported homomorphic operations
+    with pytest.raises(ValueError):
+        _ = c1 * c2
+
+    with pytest.raises(ValueError):
+        _ = c1 ^ c2
+
+    logger.info("✅ Naccache-Stern api test with pre-defined keys succeeded")
+
+
+def test_api():
+    from lightphe import LightPHE
+
+    cs = LightPHE(algorithm_name="Naccache-Stern", key_size=37)
+
+    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("✅ Naccache-Stern api test succeeded")
+
+
+@pytest.mark.skip(reason="We cannot generate Naccache-Stern keys always")
+def test_api_with_real_keys():
+    from lightphe import LightPHE
+
+    cs = LightPHE(algorithm_name="Naccache-Stern")
+
+    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("✅ Naccache-Stern api test succeeded")

{lightphe-0.0.15 → lightphe-0.0.16}/tests/test_okamoto.py

@@ -15,7 +15,7 @@ def test_okamoto():
 
     # homomorphic operations
     assert cs.decrypt(cs.add(c1, c2)) == (m1 + m2) % cs.plaintext_modulo
-    assert cs.decrypt(cs.multiply_by_contant(c1, m2)) == (m1 * m2) % cs.plaintext_modulo
+    assert cs.decrypt(cs.multiply_by_constant(c1, m2)) == (m1 * m2) % cs.plaintext_modulo
 
     # unsupported operations
     with pytest.raises(ValueError, match="Okamoto-Uchiyama is not homomorphic with respect to the multiplication"):

{lightphe-0.0.15 → lightphe-0.0.16}/tests/test_paillier.py

@@ -16,7 +16,7 @@ def test_paillier():
 
     # homomorphic operations
     assert pai.decrypt(pai.add(c1, c2)) == (m1 + m2) % pai.plaintext_modulo
-    assert pai.decrypt(pai.multiply_by_contant(c1, m2)) == (m1 * m2) % pai.plaintext_modulo
+    assert pai.decrypt(pai.multiply_by_constant(c1, m2)) == (m1 * m2) % pai.plaintext_modulo
 
     # unsupported homomorphic operations
     with pytest.raises(ValueError):

{lightphe-0.0.15 → lightphe-0.0.16}/tests/test_rsa.py

@@ -28,7 +28,7 @@ def test_rsa():
         rsa.xor(c1, c2)
 
     with pytest.raises(ValueError):
-        rsa.multiply_by_contant(c1, c2)
+        rsa.multiply_by_constant(c1, c2)
 
     with pytest.raises(ValueError):
         rsa.reencrypt(c1)

{lightphe-0.0.15 → lightphe-0.0.16}/tests/test_salary.py

@@ -26,7 +26,7 @@ def test_salary():
     ratio = 105 * pow(100, -1, cs.plaintext_modulo)
 
     # final salary should be 11000 x 1.05 = 11500
-    final_salary_encrytped = cs.multiply_by_contant(new_salary_encrypted, ratio)
+    final_salary_encrytped = cs.multiply_by_constant(new_salary_encrypted, ratio)
     assert cs.decrypt(final_salary_encrytped) == 11550
 
     logger.info("✅ Salary test succeeded")

lightphe-0.0.15/lightphe.egg-info/requires.txt

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

lightphe-0.0.15/requirements.txt

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

lightphe-0.0.15/tests/test_naccache.py

@@ -1,94 +0,0 @@
-import pytest
-from lightphe.cryptosystems.NaccacheStern import NaccacheStern
-from lightphe.commons.logger import Logger
-
-logger = Logger(module="tests/test_naccache.py")
-
-
-def test_naccache_on_plaintexts():
-    cs = NaccacheStern(key_size=37, deterministic=False)
-
-    m1 = 17
-    m2 = 21
-
-    c1 = cs.encrypt(m1)
-    c2 = cs.encrypt(m2)
-
-    assert cs.decrypt(c1) == m1 % cs.plaintext_modulo
-    assert cs.decrypt(c2) == m2 % cs.plaintext_modulo
-
-    # homomorphic operations
-    assert cs.decrypt(cs.add(c1, c2)) == (m1 + m2) % cs.plaintext_modulo
-    assert cs.decrypt(cs.multiply_by_contant(c2, m1)) == (m1 * m2) % cs.plaintext_modulo
-
-    # unsupported operations
-    with pytest.raises(ValueError):
-        cs.multiply(c1, c2)
-
-    with pytest.raises(ValueError):
-        cs.xor(c1, c2)
-
-    # re-encryption
-    c1_prime = cs.reencrypt(c1)
-    assert c1_prime != c1
-    assert cs.decrypt(c1_prime) == m1 % cs.plaintext_modulo
-    logger.info("✅ Probabilistic Naccache-Stern test succeeded")
-
-
-def test_deterministic_version():
-    cs = NaccacheStern(deterministic=True)
-
-    m1 = 17
-    m2 = 21
-
-    c1 = cs.encrypt(m1)
-    c2 = cs.encrypt(m2)
-
-    assert cs.decrypt(c1) == m1 % cs.plaintext_modulo
-    assert cs.decrypt(c2) == m2 % cs.plaintext_modulo
-
-    # homomorphic operations
-    assert cs.decrypt(cs.add(c1, c2)) == (m1 + m2) % cs.plaintext_modulo
-    assert cs.decrypt(cs.multiply_by_contant(c2, m1)) == (m1 * m2) % cs.plaintext_modulo
-
-    # unsupported operations
-    with pytest.raises(ValueError):
-        cs.multiply(c1, c2)
-
-    with pytest.raises(ValueError):
-        cs.xor(c1, c2)
-
-    with pytest.raises(ValueError):
-        cs.reencrypt(c1)
-
-    logger.info("✅ Deterministic Naccache-Stern test succeeded")
-
-
-def test_api():
-    from lightphe import LightPHE
-
-    cs = LightPHE(algorithm_name="Naccache-Stern")
-
-    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("✅ Naccache-Stern api test succeeded")