lightphe 0.0.13__tar.gz → 0.0.15__tar.gz

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: lightphe
-Version: 0.0.13
+Version: 0.0.15
 Summary: A Lightweight Partially Homomorphic Encryption Library for Python
 Home-page: https://github.com/serengil/LightPHE
 Author: Sefik Ilkin Serengil
@@ -23,8 +23,6 @@ License-File: LICENSE
 [![Tests](https://github.com/serengil/LightPHE/actions/workflows/tests.yml/badge.svg)](https://github.com/serengil/LightPHE/actions/workflows/tests.yml)
 [![License](http://img.shields.io/:license-MIT-green.svg?style=flat)](https://github.com/serengil/LightPHE/blob/master/LICENSE)
 [![arXiv](https://img.shields.io/badge/arXiv-2408.05219-b31b1b.svg?logo=arXiv)](https://arxiv.org/abs/2408.05219)
-[![Hacker News](https://img.shields.io/badge/dynamic/json?color=orange&label=Hacker%20News&query=score&url=https%3A%2F%2Fhacker-news.firebaseio.com%2Fv0%2Fitem%2F43024283.json&logo=y-combinator)](https://news.ycombinator.com/item?id=43024283)
-<!-- [![DOI](http://img.shields.io/:DOI-10.48550/arXiv.2408.05219-blue.svg?style=flat)](https://arxiv.org/abs/2408.05219) -->
 
 [![Blog](https://img.shields.io/:blog-sefiks.com-blue.svg?style=flat&logo=wordpress)](https://sefiks.com)
 [![YouTube](https://img.shields.io/:youtube-@sefiks-red.svg?style=flat&logo=youtube)](https://www.youtube.com/@sefiks?sub_confirmation=1)
@@ -254,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
 )
 ```
 
@@ -266,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) page for a list of all supported forms, curves and their details.
 
 ### Vector Embeddings and Tensors
 
@@ -345,24 +341,42 @@ 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))
 
-# encrypt embedding
+# build an additively homomorphic cryptosystem (e.g. Paillier) on-prem
+cs = LightPHE(algorithm_name = "Paillier", precision = 19)
+
+# 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
 ```
 
 # Contributing
@@ -392,13 +406,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.13 → lightphe-0.0.15}/README.md

@@ -7,8 +7,6 @@
 [![Tests](https://github.com/serengil/LightPHE/actions/workflows/tests.yml/badge.svg)](https://github.com/serengil/LightPHE/actions/workflows/tests.yml)
 [![License](http://img.shields.io/:license-MIT-green.svg?style=flat)](https://github.com/serengil/LightPHE/blob/master/LICENSE)
 [![arXiv](https://img.shields.io/badge/arXiv-2408.05219-b31b1b.svg?logo=arXiv)](https://arxiv.org/abs/2408.05219)
-[![Hacker News](https://img.shields.io/badge/dynamic/json?color=orange&label=Hacker%20News&query=score&url=https%3A%2F%2Fhacker-news.firebaseio.com%2Fv0%2Fitem%2F43024283.json&logo=y-combinator)](https://news.ycombinator.com/item?id=43024283)
-<!-- [![DOI](http://img.shields.io/:DOI-10.48550/arXiv.2408.05219-blue.svg?style=flat)](https://arxiv.org/abs/2408.05219) -->
 
 [![Blog](https://img.shields.io/:blog-sefiks.com-blue.svg?style=flat&logo=wordpress)](https://sefiks.com)
 [![YouTube](https://img.shields.io/:youtube-@sefiks-red.svg?style=flat&logo=youtube)](https://www.youtube.com/@sefiks?sub_confirmation=1)
@@ -238,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
 )
 ```
 
@@ -250,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) page for a list of all supported forms, curves and their details.
 
 ### Vector Embeddings and Tensors
 
@@ -329,24 +325,42 @@ 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))
 
-# encrypt embedding
+# build an additively homomorphic cryptosystem (e.g. Paillier) on-prem
+cs = LightPHE(algorithm_name = "Paillier", precision = 19)
+
+# 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
 ```
 
 # Contributing
@@ -376,13 +390,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.13 → lightphe-0.0.15}/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.13"
+VERSION = "0.0.15"
 
 
 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.13 → lightphe-0.0.15}/lightphe/cryptosystems/Benaloh.py

@@ -169,12 +169,6 @@ 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:
         """
         Multiply a ciphertext with a plain constant.

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

@@ -125,12 +125,6 @@ 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:
         """
         Multiply a ciphertext by a known plain constant

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

@@ -169,9 +169,6 @@ 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:
         if self.exponential is False:
             raise ValueError("ElGamal is not supporting multiplying ciphertext by a known constant")

{lightphe-0.0.13 → lightphe-0.0.15}/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,10 +166,7 @@ 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:
         """
@@ -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.13 → lightphe-0.0.15}/lightphe/cryptosystems/GoldwasserMicali.py

@@ -193,9 +193,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")

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

@@ -257,12 +257,6 @@ class NaccacheStern(Homomorphic):
         """
         return (ciphertext1 * ciphertext2) % self.ciphertext_modulo
 
-    def multiply(self, ciphertext1: int, ciphertext2: int) -> int:
-        raise ValueError("Naccache-Stern is not homomorphic with respect to the multiplication")
-
-    def xor(self, ciphertext1: int, ciphertext2: int) -> int:
-        raise ValueError("Naccache-Stern is not homomorphic with respect to the exclusive or")
-
     def multiply_by_contant(self, ciphertext: int, constant: int) -> int:
         """
         Multiply a ciphertext with a plain constant.

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

@@ -127,16 +127,6 @@ class OkamotoUchiyama(Homomorphic):
         n = self.keys["public_key"]["n"]
         return (ciphertext1 * ciphertext2) % n
 
-    def multiply(self, ciphertext1: int, ciphertext2: int) -> int:
-        raise ValueError(
-            "Okamoto-Uchiyama is not homomorphic with respect to the multiplication"
-        )
-
-    def xor(self, ciphertext1: int, ciphertext2: int) -> int:
-        raise ValueError(
-            "Okamoto-Uchiyama is not homomorphic with respect to the exclusive or"
-        )
-
     def multiply_by_contant(self, ciphertext: int, constant: int) -> int:
         """
         Multiply a ciphertext with a plain constant.

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

@@ -112,12 +112,6 @@ class Paillier(Homomorphic):
         n = self.keys["public_key"]["n"]
         return (ciphertext1 * ciphertext2) % (n * n)
 
-    def multiply(self, ciphertext1: int, ciphertext2: int) -> int:
-        raise ValueError("Paillier is not homomorphic with respect to the multiplication")
-
-    def xor(self, ciphertext1: int, ciphertext2: int) -> int:
-        raise ValueError("Paillier is not homomorphic with respect to the exclusive or")
-
     def multiply_by_contant(self, ciphertext: int, constant: int) -> int:
         """
         Multiply a ciphertext with a plain constant.

{lightphe-0.0.13 → lightphe-0.0.15}/lightphe/cryptosystems/RSA.py

@@ -129,15 +129,3 @@ class RSA(Homomorphic):
         """
         n = self.keys["public_key"]["n"]
         return (ciphertext1 * ciphertext2) % n
-
-    def add(self, ciphertext1: int, ciphertext2: int) -> int:
-        raise ValueError("RSA is not homomorphic with respect to the addition")
-
-    def xor(self, ciphertext1: int, ciphertext2: int) -> int:
-        raise ValueError("RSA is not homomorphic with respect to the exclusive or")
-
-    def multiply_by_contant(self, ciphertext: int, constant: int) -> int:
-        raise ValueError("RSA is not supporting multiplying ciphertext by a known constant")
-
-    def reencrypt(self, ciphertext: int) -> int:
-        raise ValueError("RSA does not support re-encryption")

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

@@ -1,6 +1,10 @@
+# built-in dependencies
 from typing import Optional, Union
 from abc import ABC, abstractmethod
 
+# project dependencies
+from lightphe.models.Algorithm import Algorithm
+
 # Signature for supported cryptosystems
 
 
@@ -27,26 +31,27 @@ class Homomorphic(ABC):
     def decrypt(self, ciphertext: Union[int, tuple, list]) -> int:
         pass
 
-    @abstractmethod
     def add(
         self, ciphertext1: Union[int, tuple, list], ciphertext2: Union[int, tuple, list]
     ) -> Union[int, tuple, list]:
-        pass
+        raise ValueError(f"{self.get_algorithm_name()} is not homomorphic with respect to the addition")
 
-    @abstractmethod
     def multiply(
         self, ciphertext1: Union[int, tuple, list], ciphertext2: Union[int, tuple, list]
     ) -> Union[int, tuple]:
-        pass
+        raise ValueError(f"{self.get_algorithm_name()} is not homomorphic with respect to the multiplication")
 
-    @abstractmethod
     def xor(self, ciphertext1: list, ciphertext2: list) -> list:
-        pass
+        raise ValueError(f"{self.get_algorithm_name()} is not homomorphic with respect to the exclusive or")
 
-    @abstractmethod
     def multiply_by_contant(self, ciphertext: Union[int, tuple, list], constant: int) -> int:
-        pass
+        raise ValueError(f"{self.get_algorithm_name()} is not supporting multiplying ciphertext by a known constant")
 
-    @abstractmethod
     def reencrypt(self, ciphertext: Union[int, tuple, list]) -> Union[int, tuple, list]:
-        pass
+        raise ValueError(f"{self.get_algorithm_name()} does not support re-encryption")
+
+    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"
+        return algorithm_name