lightphe 0.0.14__tar.gz → 0.0.16__tar.gz

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: lightphe
-Version: 0.0.14
+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)
 
@@ -252,11 +252,9 @@ ECC is a powerful public-key cryptosystem based on the algebraic structure of el
 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.
 
 ```python
-forms = ["weierstass", "edwards", "koblitz"]
-
 phe = LightPHE(
     algorithm_name="EllipticCurve-ElGamal",
-    form=forms[1],
+    form="edwards", # or weierstrass, koblitz
 )
 ```
 
@@ -264,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/LightPHE/tree/master/lightphe/elliptic_curve_forms) 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
 
@@ -343,26 +341,50 @@ Many machine learning models rely on a two-tower architecture, including facial
 For example, suppose all facial embeddings in your database are encrypted on-prem in advance. When verifying an identity, the attempted facial embedding is generated on an edge device or in the cloud. You can compute the encrypted similarity by performing a dot product between the encrypted vector and the plain vector, ensuring secure comparison without decrypting sensitive data. Only additively homomorphic cryptosystems offer encrypted similarity calculation.
 
 ```python
-# build an additively homomorphic cryptosystem (e.g. Paillier)
-cs = LightPHE("Paillier")
-
-# define plain vectors - suppose those are l2 normalized already
+# define a plain vectors for source and target
 alpha = [7.1, 5.2, 5.3, 2.4, 3.5, 4.6]  # On-prem vector (user tower)
 beta = [5.6, 3.7, 2.8, 4, 0, 5.9]  # Cloud vector (item tower)
+expected_similarity = sum(x * y for x, y in zip(alpha, beta))
+
+# build an additively homomorphic cryptosystem (e.g. Paillier) on-prem
+cs = LightPHE(algorithm_name = "Paillier", precision = 19)
 
-# encrypt embedding
+# export keys
+cs.export_keys("secret.txt")
+cs.export_keys("public.txt", public=True)
+
+# encrypt source embedding
 encrypted_alpha = cs.encrypt(alpha)
 
-# dot product of encrypted embedding and plain embedding
+# remove cryptosystem and plain alpha not to be leaked in cloud
+del cs, alpha
+
+# restore the cryptosystem in cloud with only public key
+cloud_cs = LightPHE(algorithm_name = "Paillier", precision = 19, key_file = "public.txt")
+
+# dot product of encrypted and plain embedding pair
 encrypted_cosine_similarity = encrypted_alpha @ beta
 
-# decrypt similarity
-cosine_similarity = cs.decrypt(encrypted_cosine_similarity)[0]
+# computed by the cloud but cloud cannot decrypt it
+with pytest.raises(ValueError, match="must have private key"):
+    cloud_cs.decrypt(encrypted_cosine_similarity)
+
+# restore the cryptosystem on-prem with secret key
+cs = LightPHE(algorithm_name = "Paillier", precision = 19, key_file = "secret.txt")
+
+# decrypt similarity (on prem)
+calculated_similarity = cs.decrypt(encrypted_cosine_similarity)[0]
 
 # proof of work
-assert abs(cosine_similarity - sum(x * y for x, y in zip(alpha, beta))) < 1e-2
+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 +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.
@@ -390,13 +412,22 @@ Also, your company's logo will be shown on README on GitHub if you become sponso
 Please cite LightPHE in your publications if it helps your research. Here is its BibTex entry:
 
 ```BibTeX
-@misc{serengil2024lightphe,
-   title     = {LightPHE: Integrating Partially Homomorphic Encryption into Python with Extensive Cloud Environment Evaluations}, 
-   author    = {Serengil, Sefik Ilkin and Ozpinar, Alper},
-   year      = {2024},
-   publisher = {arXiv},
-   url       = {https://arxiv.org/abs/2408.05219},
-   doi       = {10.48550/arXiv.2408.05219}
+@article{serengil2024lightphe,
+  title={LightPHE: Integrating Partially Homomorphic Encryption into Python with Extensive Cloud Environment Evaluations},
+  author={Serengil, Sefik Ilkin and Ozpinar, Alper},
+  journal={arXiv preprint arXiv:2408.05219},
+  note={doi: 10.48550/arXiv.2408.05219. [Online]. Available: \url{https://arxiv.org/abs/2408.05219}},
+  year={2025}
+}
+```
+
+```BibTeX
+@article{serengil2025vectorsimilarity,
+  title={Encrypted Vector Similarity Computations Using Partially Homomorphic Encryption: Applications and Performance Analysis},
+  author={Serengil, Sefik and Ozpinar, Alper},
+  journal={arXiv preprint arXiv:2503.05850},
+  note={doi: 10.48550/arXiv.2503.05850. [Online]. Available: \url{https://arxiv.org/abs/2503.05850}},
+  year={2025}
 }
 ```
 

{lightphe-0.0.14 → 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)
 
@@ -236,11 +236,9 @@ ECC is a powerful public-key cryptosystem based on the algebraic structure of el
 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.
 
 ```python
-forms = ["weierstass", "edwards", "koblitz"]
-
 phe = LightPHE(
     algorithm_name="EllipticCurve-ElGamal",
-    form=forms[1],
+    form="edwards", # or weierstrass, koblitz
 )
 ```
 
@@ -248,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/LightPHE/tree/master/lightphe/elliptic_curve_forms) 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
 
@@ -327,26 +325,50 @@ Many machine learning models rely on a two-tower architecture, including facial
 For example, suppose all facial embeddings in your database are encrypted on-prem in advance. When verifying an identity, the attempted facial embedding is generated on an edge device or in the cloud. You can compute the encrypted similarity by performing a dot product between the encrypted vector and the plain vector, ensuring secure comparison without decrypting sensitive data. Only additively homomorphic cryptosystems offer encrypted similarity calculation.
 
 ```python
-# build an additively homomorphic cryptosystem (e.g. Paillier)
-cs = LightPHE("Paillier")
-
-# define plain vectors - suppose those are l2 normalized already
+# define a plain vectors for source and target
 alpha = [7.1, 5.2, 5.3, 2.4, 3.5, 4.6]  # On-prem vector (user tower)
 beta = [5.6, 3.7, 2.8, 4, 0, 5.9]  # Cloud vector (item tower)
+expected_similarity = sum(x * y for x, y in zip(alpha, beta))
+
+# build an additively homomorphic cryptosystem (e.g. Paillier) on-prem
+cs = LightPHE(algorithm_name = "Paillier", precision = 19)
 
-# encrypt embedding
+# export keys
+cs.export_keys("secret.txt")
+cs.export_keys("public.txt", public=True)
+
+# encrypt source embedding
 encrypted_alpha = cs.encrypt(alpha)
 
-# dot product of encrypted embedding and plain embedding
+# remove cryptosystem and plain alpha not to be leaked in cloud
+del cs, alpha
+
+# restore the cryptosystem in cloud with only public key
+cloud_cs = LightPHE(algorithm_name = "Paillier", precision = 19, key_file = "public.txt")
+
+# dot product of encrypted and plain embedding pair
 encrypted_cosine_similarity = encrypted_alpha @ beta
 
-# decrypt similarity
-cosine_similarity = cs.decrypt(encrypted_cosine_similarity)[0]
+# computed by the cloud but cloud cannot decrypt it
+with pytest.raises(ValueError, match="must have private key"):
+    cloud_cs.decrypt(encrypted_cosine_similarity)
+
+# restore the cryptosystem on-prem with secret key
+cs = LightPHE(algorithm_name = "Paillier", precision = 19, key_file = "secret.txt")
+
+# decrypt similarity (on prem)
+calculated_similarity = cs.decrypt(encrypted_cosine_similarity)[0]
 
 # proof of work
-assert abs(cosine_similarity - sum(x * y for x, y in zip(alpha, beta))) < 1e-2
+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.
@@ -360,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.
@@ -374,13 +396,22 @@ Also, your company's logo will be shown on README on GitHub if you become sponso
 Please cite LightPHE in your publications if it helps your research. Here is its BibTex entry:
 
 ```BibTeX
-@misc{serengil2024lightphe,
-   title     = {LightPHE: Integrating Partially Homomorphic Encryption into Python with Extensive Cloud Environment Evaluations}, 
-   author    = {Serengil, Sefik Ilkin and Ozpinar, Alper},
-   year      = {2024},
-   publisher = {arXiv},
-   url       = {https://arxiv.org/abs/2408.05219},
-   doi       = {10.48550/arXiv.2408.05219}
+@article{serengil2024lightphe,
+  title={LightPHE: Integrating Partially Homomorphic Encryption into Python with Extensive Cloud Environment Evaluations},
+  author={Serengil, Sefik Ilkin and Ozpinar, Alper},
+  journal={arXiv preprint arXiv:2408.05219},
+  note={doi: 10.48550/arXiv.2408.05219. [Online]. Available: \url{https://arxiv.org/abs/2408.05219}},
+  year={2025}
+}
+```
+
+```BibTeX
+@article{serengil2025vectorsimilarity,
+  title={Encrypted Vector Similarity Computations Using Partially Homomorphic Encryption: Applications and Performance Analysis},
+  author={Serengil, Sefik and Ozpinar, Alper},
+  journal={arXiv preprint arXiv:2503.05850},
+  note={doi: 10.48550/arXiv.2503.05850. [Online]. Available: \url{https://arxiv.org/abs/2503.05850}},
+  year={2025}
 }
 ```
 

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

@@ -9,13 +9,16 @@ 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
 from lightphe.models.Ciphertext import Ciphertext
 from lightphe.models.Algorithm import Algorithm
 from lightphe.models.Tensor import Fraction, EncryptedTensor
-from lightphe.models.EllipticCurve import EllipticCurvePoint
 from lightphe.commons import phe_utils
 from lightphe.commons.logger import Logger
 
@@ -29,16 +32,13 @@ from lightphe.cryptosystems.Benaloh import Benaloh
 from lightphe.cryptosystems.NaccacheStern import NaccacheStern
 from lightphe.cryptosystems.GoldwasserMicali import GoldwasserMicali
 from lightphe.cryptosystems.EllipticCurveElGamal import EllipticCurveElGamal
-from lightphe.elliptic_curve_forms.weierstrass import Weierstrass
-from lightphe.elliptic_curve_forms.edwards import TwistedEdwards
-from lightphe.elliptic_curve_forms.koblitz import Koblitz
 
 
 # pylint: disable=eval-used, simplifiable-if-expression, too-few-public-methods
 
 logger = Logger(module="lightphe/__init__.py")
 
-VERSION = "0.0.14"
+VERSION = "0.0.16"
 
 
 class LightPHE:
@@ -94,7 +94,7 @@ class LightPHE:
 
     def __build_cryptosystem(
         self,
-        algorithm_name: str,
+        algorithm_name: str = "Paillier",
         keys: Optional[dict] = None,
         key_size: Optional[int] = None,
         form: Optional[str] = None,
@@ -115,6 +115,7 @@ class LightPHE:
             algorithm_name (str): RSA | ElGamal | Exponential-ElGamal | EllipticCurve-ElGamal
                 | Paillier | Damgard-Jurik | Okamoto-Uchiyama | Benaloh | Naccache-Stern
                 | Goldwasser-Micali | Edwards-ElGamal
+                Default is Paillier.
             keys (dict): optional private-public key pair
             key_file (str): if keys are exported, you can load them into cryptosystem
             key_size (int): key size in bits
@@ -464,44 +465,3 @@ def encrypt_float(
         logger.error(f"Exception while running encrypt_float: {str(err)}")
         logger.error(traceback.format_exc())
         raise err
-
-
-class ECC:
-    __version__ = VERSION
-
-    def __init__(
-        self, form_name: Optional[str] = None, curve_name: Optional[str] = None
-    ):
-        """
-        Construct an Elliptic Curve over a finite field (prime or binary)
-        Args:
-            form_name (str): specifies the form of the elliptic curve.
-                Options: 'weierstrass' (default), 'edwards', 'koblitz'.
-            curve_name (str): specifies the elliptic curve to use.
-                Options:
-                 - e.g. ed25519, ed448 for edwards form
-                 - 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
-        """
-        if form_name is None or form_name == "weierstrass":
-            self.curve = Weierstrass(curve=curve_name)
-        elif form_name in "edwards":
-            self.curve = TwistedEdwards(curve=curve_name)
-        elif form_name in "koblitz":
-            self.curve = Koblitz(curve=curve_name)
-        else:
-            raise ValueError(f"unimplemented curve form - {form_name}")
-
-        # base point
-        self.G = EllipticCurvePoint(self.curve.G[0], self.curve.G[1], self.curve)
-
-        # order of the curve
-        self.n = self.curve.n
-
-        # point at infinity or neutral / identity element
-        self.O = EllipticCurvePoint(self.curve.O[0], self.curve.O[1], self.curve)
-
-        # modulo
-        self.modulo = self.curve.modulo

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

@@ -169,13 +169,7 @@ class Benaloh(Homomorphic):
         n = self.keys["public_key"]["n"]
         return (ciphertext1 * ciphertext2) % n
 
-    def multiply(self, ciphertext1: int, ciphertext2: int) -> int:
-        raise ValueError("Benaloh is not homomorphic with respect to the multiplication")
-
-    def xor(self, ciphertext1: int, ciphertext2: int) -> int:
-        raise ValueError("Benaloh is not homomorphic with respect to the exclusive or")
-
-    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.14 → lightphe-0.0.16}/lightphe/cryptosystems/DamgardJurik.py

@@ -125,13 +125,7 @@ class DamgardJurik(Homomorphic):
         modulo = pow(n, s + 1)
         return (ciphertext1 * ciphertext2) % modulo
 
-    def multiply(self, ciphertext1: int, ciphertext2: int) -> int:
-        raise ValueError("Damgard-Jurik is not homomorphic with respect to the multiplication")
-
-    def xor(self, ciphertext1: int, ciphertext2: int) -> int:
-        raise ValueError("Damgard-Jurik is not homomorphic with respect to the exclusive or")
-
-    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.14 → lightphe-0.0.16}/lightphe/cryptosystems/ElGamal.py

@@ -169,10 +169,7 @@ class ElGamal(Homomorphic):
         p = self.keys["public_key"]["p"]
         return (ciphertext1[0] * ciphertext2[0]) % p, (ciphertext1[1] * ciphertext2[1]) % p
 
-    def xor(self, ciphertext1: tuple, ciphertext2: tuple) -> int:
-        raise ValueError("ElGamal is not homomorphic with respect to the exclusive or")
-
-    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.14 → lightphe-0.0.16}/lightphe/cryptosystems/EllipticCurveElGamal.py

@@ -2,9 +2,12 @@
 import random
 from typing import Optional
 
+# 3rd party dependencies
+from lightecc import LightECC as ECC
+from lightecc.interfaces.elliptic_curve import EllipticCurvePoint
+
 # project dependencies
 from lightphe.models.Homomorphic import Homomorphic
-from lightphe.models.EllipticCurve import EllipticCurvePoint
 from lightphe.commons.logger import Logger
 
 logger = Logger(module="lightphe/cryptosystems/EllipticCurveElGamal.py")
@@ -40,9 +43,6 @@ class EllipticCurveElGamal(Homomorphic):
                  - secp256k1 for weierstrass form
                 This parameter is only used if `algorithm_name` is 'EllipticCurve-ElGamal'.
         """
-        # to avoid circular import, import ECC class here
-        from lightphe import ECC
-
         self.ecc = ECC(form_name=form, curve_name=curve)
 
         self.keys = keys or self.generate_keys(key_size or self.ecc.n.bit_length())
@@ -142,11 +142,6 @@ class EllipticCurveElGamal(Homomorphic):
 
         return s_prime / self.ecc.G
 
-    def multiply(self, ciphertext1: tuple, ciphertext2: tuple) -> tuple:
-        raise ValueError(
-            "Elliptic Curve ElGamal is not homomorphic with respect to the multiplication"
-        )
-
     def add(self, ciphertext1: tuple, ciphertext2: tuple) -> tuple:
         """
         Perform homomorphic addition on encrypted data
@@ -171,12 +166,9 @@ class EllipticCurveElGamal(Homomorphic):
 
         return a.get_point(), b.get_point()
 
-    def xor(self, ciphertext1: tuple, ciphertext2: tuple) -> int:
-        raise ValueError(
-            "Elliptic Curve ElGamal is not homomorphic with respect to the exclusive or"
-        )
 
-    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)
@@ -198,8 +190,3 @@ class EllipticCurveElGamal(Homomorphic):
         Q_prime = Q * constant
 
         return P_prime.get_point(), Q_prime.get_point()
-
-    def reencrypt(self, ciphertext: tuple) -> tuple:
-        raise ValueError(
-            "Elliptic Curve ElGamal does not support regeneration of ciphertext"
-        )

{lightphe-0.0.14 → 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"] = {}
+        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
 
-        # picking a prime p
-        p = sympy.randprime(200, 2 ** int(key_size / 2) - 1)
-        assert isinstance(p, int)
+            keys = {
+                "public_key": {"n": n, "x": x},
+                "private_key": {"p": p, "q": q},
+            }
 
-        # picking a prime q
-        q = sympy.randprime(200, 2 ** int(key_size / 2) - 1)
-        assert isinstance(q, int)
+            logger.debug(
+                f"Goldwasser-Micali keys generated after {attempt+1} attempts, n bits: {n.bit_length()}"
+            )
 
-        n = p * q
+            return keys
 
-        # 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
-        keys["public_key"]["x"] = x
-
-        keys["private_key"]["p"] = p
-        keys["private_key"]["q"] = q
-
-        return keys
+        raise RuntimeError(f"Failed to generate keys after {max_tries} attempts")
 
     def generate_random_key(self) -> int:
         """
@@ -193,9 +196,3 @@ class GoldwasserMicali(Homomorphic):
             ciphertext3.append((c1 * c2) % self.ciphertext_modulo)
 
         return ciphertext3
-
-    def multiply_by_contant(self, ciphertext: int, constant: int):
-        raise ValueError("Goldwasser-Micali does not support multiplying with constant")
-
-    def reencrypt(self, ciphertext: int):
-        raise ValueError("Goldwasser-Micali does not support re-encryption")