lightphe 0.0.1__tar.gz → 0.0.2__tar.gz

{lightphe-0.0.1 → lightphe-0.0.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: lightphe
-Version: 0.0.1
+Version: 0.0.2
 Summary: A Lightweight Partially Homomorphic Encryption Library for Python
 Home-page: https://github.com/serengil/LightPHE
 Author: Sefik Ilkin Serengil
@@ -31,13 +31,13 @@ License-File: LICENSE
 
 </div>
 
-<p align="center"><img src="icons/phi.png" width="200" height="240"></p>
+<p align="center"><img src="https://raw.githubusercontent.com/serengil/LightPHE/master/icons/phi.png" width="200" height="240"></p>
 
 LightPHE is a lightweight partially homomorphic encryption library for python. It is a hybrid homomoprhic encryption library wrapping many schemes such as [`RSA`](https://sefiks.com/2023/03/06/a-step-by-step-partially-homomorphic-encryption-example-with-rsa-in-python/), [`ElGamal`](https://sefiks.com/2023/03/27/a-step-by-step-partially-homomorphic-encryption-example-with-elgamal-in-python/), [`Exponential ElGamal`](https://sefiks.com/2023/03/27/a-step-by-step-partially-homomorphic-encryption-example-with-elgamal-in-python/), [`Elliptic Curve ElGamal`](https://sefiks.com/2018/08/21/elliptic-curve-elgamal-encryption/), [`Paillier`](https://sefiks.com/2023/04/03/a-step-by-step-partially-homomorphic-encryption-example-with-paillier-in-python/), [`Damgard-Jurik`](https://sefiks.com/2023/10/20/a-step-by-step-partially-homomorphic-encryption-example-with-damgard-jurik-in-python/), [`Okamoto–Uchiyama`](https://sefiks.com/2023/10/20/a-step-by-step-partially-homomorphic-encryption-example-with-okamoto-uchiyama-in-python/), [`Benaloh`](https://sefiks.com/2023/10/06/a-step-by-step-partially-homomorphic-encryption-example-with-benaloh-in-python-from-scratch/), [`Naccache–Stern`](https://sefiks.com/2023/10/26/a-step-by-step-partially-homomorphic-encryption-example-with-naccache-stern-in-python/), [`Goldwasser–Micali`](https://sefiks.com/2023/10/27/a-step-by-step-partially-homomorphic-encryption-example-with-goldwasser-micali-in-python/).
 
 Even though fully homomorphic encryption (FHE) has become available in recent times, but when considering the trade-offs, LightPHE emerges as a more efficient and practical choice. If your specific task doesn't demand the full homomorphic capabilities, opting for partial homomorphism with LightPHE is the logical decision. LightPHE is notably faster and demands fewer computational resources compared to FHE. Besides, it generates smaller ciphertexts, making it well-suited for memory-constrained environments. Finally, LightPHE strikes a favorable balance between security and efficiency for practical use cases.
 
-# Installation
+# Installation [![PyPI](https://img.shields.io/pypi/v/lightphe.svg)](https://pypi.org/project/lightphe/)
 
 The easiest way to install the LightPHE package is to install it from python package index (PyPI).
 
@@ -125,8 +125,8 @@ assert cs.decrypt(c1 + c2) == m1 + m2
 Besides, Paillier is supporting multiplying ciphertexts by a known plain constant. Simply put, decryption of scalar multiplication of ciphertext is equivalent to that constant times plaintext as well.
 
 ```python
-# scalar multiplication
-k = 5
+# scalar multiplication (increase its value 5%)
+k = 1.05
 assert cs.decrypt(k * c1) == k * m1
 ```
 
@@ -159,6 +159,16 @@ All PRs are more than welcome! If you are planning to contribute a large patch,
 
 You should be able run `make test` and `make lint` commands successfully before committing. Once a PR is created, GitHub test workflow will be run automatically and unit test results will be available in [GitHub actions](https://github.com/serengil/LightPHE/actions/workflows/tests.yml) before approval. Besides, workflow will evaluate the code with pylint as well.
 
+# Support
+
+There are many ways to support a project - starring⭐️ the GitHub repo is just one 🙏
+
+You can also support this work on [Patreon](https://www.patreon.com/serengil?repo=lightphe) or [GitHub Sponsors](https://github.com/sponsors/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%">
+</a>
+
 # Citation
 
 Please cite LightPHE in your publications if it helps your research. Here is its BibTex entry:
@@ -173,10 +183,10 @@ Please cite LightPHE in your publications if it helps your research. Here is its
 }
 ```
 
-Also, if you use LightPHE in your projects, please add `LightPHE` in the `requirements.txt`.
+Also, if you use LightPHE in your projects, please add `lightphe` in the `requirements.txt`.
 
 # License
 
-LightPHE is licensed under the MIT License - see [`LICENSE`](LICENSE) for more details.
+LightPHE is licensed under the MIT License - see [`LICENSE`](https://github.com/serengil/LightPHE/blob/master/LICENSE) for more details.
 
 

{lightphe-0.0.1 → lightphe-0.0.2}/README.md

@@ -15,13 +15,13 @@
 
 </div>
 
-<p align="center"><img src="icons/phi.png" width="200" height="240"></p>
+<p align="center"><img src="https://raw.githubusercontent.com/serengil/LightPHE/master/icons/phi.png" width="200" height="240"></p>
 
 LightPHE is a lightweight partially homomorphic encryption library for python. It is a hybrid homomoprhic encryption library wrapping many schemes such as [`RSA`](https://sefiks.com/2023/03/06/a-step-by-step-partially-homomorphic-encryption-example-with-rsa-in-python/), [`ElGamal`](https://sefiks.com/2023/03/27/a-step-by-step-partially-homomorphic-encryption-example-with-elgamal-in-python/), [`Exponential ElGamal`](https://sefiks.com/2023/03/27/a-step-by-step-partially-homomorphic-encryption-example-with-elgamal-in-python/), [`Elliptic Curve ElGamal`](https://sefiks.com/2018/08/21/elliptic-curve-elgamal-encryption/), [`Paillier`](https://sefiks.com/2023/04/03/a-step-by-step-partially-homomorphic-encryption-example-with-paillier-in-python/), [`Damgard-Jurik`](https://sefiks.com/2023/10/20/a-step-by-step-partially-homomorphic-encryption-example-with-damgard-jurik-in-python/), [`Okamoto–Uchiyama`](https://sefiks.com/2023/10/20/a-step-by-step-partially-homomorphic-encryption-example-with-okamoto-uchiyama-in-python/), [`Benaloh`](https://sefiks.com/2023/10/06/a-step-by-step-partially-homomorphic-encryption-example-with-benaloh-in-python-from-scratch/), [`Naccache–Stern`](https://sefiks.com/2023/10/26/a-step-by-step-partially-homomorphic-encryption-example-with-naccache-stern-in-python/), [`Goldwasser–Micali`](https://sefiks.com/2023/10/27/a-step-by-step-partially-homomorphic-encryption-example-with-goldwasser-micali-in-python/).
 
 Even though fully homomorphic encryption (FHE) has become available in recent times, but when considering the trade-offs, LightPHE emerges as a more efficient and practical choice. If your specific task doesn't demand the full homomorphic capabilities, opting for partial homomorphism with LightPHE is the logical decision. LightPHE is notably faster and demands fewer computational resources compared to FHE. Besides, it generates smaller ciphertexts, making it well-suited for memory-constrained environments. Finally, LightPHE strikes a favorable balance between security and efficiency for practical use cases.
 
-# Installation
+# Installation [![PyPI](https://img.shields.io/pypi/v/lightphe.svg)](https://pypi.org/project/lightphe/)
 
 The easiest way to install the LightPHE package is to install it from python package index (PyPI).
 
@@ -109,8 +109,8 @@ assert cs.decrypt(c1 + c2) == m1 + m2
 Besides, Paillier is supporting multiplying ciphertexts by a known plain constant. Simply put, decryption of scalar multiplication of ciphertext is equivalent to that constant times plaintext as well.
 
 ```python
-# scalar multiplication
-k = 5
+# scalar multiplication (increase its value 5%)
+k = 1.05
 assert cs.decrypt(k * c1) == k * m1
 ```
 
@@ -143,6 +143,16 @@ All PRs are more than welcome! If you are planning to contribute a large patch,
 
 You should be able run `make test` and `make lint` commands successfully before committing. Once a PR is created, GitHub test workflow will be run automatically and unit test results will be available in [GitHub actions](https://github.com/serengil/LightPHE/actions/workflows/tests.yml) before approval. Besides, workflow will evaluate the code with pylint as well.
 
+# Support
+
+There are many ways to support a project - starring⭐️ the GitHub repo is just one 🙏
+
+You can also support this work on [Patreon](https://www.patreon.com/serengil?repo=lightphe) or [GitHub Sponsors](https://github.com/sponsors/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%">
+</a>
+
 # Citation
 
 Please cite LightPHE in your publications if it helps your research. Here is its BibTex entry:
@@ -157,8 +167,8 @@ Please cite LightPHE in your publications if it helps your research. Here is its
 }
 ```
 
-Also, if you use LightPHE in your projects, please add `LightPHE` in the `requirements.txt`.
+Also, if you use LightPHE in your projects, please add `lightphe` in the `requirements.txt`.
 
 # License
 
-LightPHE is licensed under the MIT License - see [`LICENSE`](LICENSE) for more details.
+LightPHE is licensed under the MIT License - see [`LICENSE`](https://github.com/serengil/LightPHE/blob/master/LICENSE) for more details.

lightphe-0.0.2/lightphe/__init__.py

@@ -0,0 +1,219 @@
+import json
+from typing import Optional, Union
+
+from lightphe.models.Ciphertext import Ciphertext
+from lightphe.models.Algorithm import Algorithm
+from lightphe.cryptosystems.RSA import RSA
+from lightphe.cryptosystems.ElGamal import ElGamal
+from lightphe.cryptosystems.Paillier import Paillier
+from lightphe.cryptosystems.DamgardJurik import DamgardJurik
+from lightphe.cryptosystems.OkamotoUchiyama import OkamotoUchiyama
+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.commons.logger import Logger
+
+# pylint: disable=eval-used
+
+logger = Logger()
+
+
+class LightPHE:
+    def __init__(
+        self,
+        algorithm_name: str,
+        keys: Optional[dict] = None,
+        key_file: Optional[str] = None,
+        key_size: Optional[int] = None,
+    ):
+        """
+        Build LightPHE class
+        Args:
+            algorithm_name (str): RSA | ElGamal | Exponential-ElGamal | EllipticCurve-ElGamal
+                | Paillier | Damgard-Jurik | Okamoto-Uchiyama | Benaloh | Naccache-Stern
+                | Goldwasser-Micali
+            keys (dict): optional private-public key pair
+            key_file (str): if keys are exported, you can load them into cryptosystem
+            key_size (int): key size in bits
+        """
+        self.algorithm_name = algorithm_name
+
+        if key_file is not None:
+            keys = self.restore_keys(target_file=key_file)
+
+        self.cs = self.build_cryptosystem(
+            algorithm_name=algorithm_name, keys=keys, key_size=key_size
+        )
+
+    def build_cryptosystem(
+        self,
+        algorithm_name: str,
+        keys: Optional[dict] = None,
+        key_size: Optional[int] = None,
+    ) -> Union[
+        RSA,
+        ElGamal,
+        Paillier,
+        DamgardJurik,
+        OkamotoUchiyama,
+        Benaloh,
+        NaccacheStern,
+        EllipticCurveElGamal,
+    ]:
+        """
+        Build a cryptosystem among partially homomorphic algorithms
+        Args:
+            algorithm_name (str): RSA | ElGamal | Exponential-ElGamal | EllipticCurve-ElGamal
+                | Paillier | Damgard-Jurik | Okamoto-Uchiyama | Benaloh | Naccache-Stern
+                | Goldwasser-Micali
+            keys (dict): optional private-public key pair
+            key_file (str): if keys are exported, you can load them into cryptosystem
+            key_size (int): key size in bits
+        Returns
+            cryptosystem
+        """
+
+        if key_size is None:
+            key_size = self.recommend_key_size(algorithm_name=algorithm_name)
+
+        # build cryptosystem
+        if algorithm_name == Algorithm.RSA:
+            cs = RSA(keys=keys, key_size=key_size)
+        elif algorithm_name == Algorithm.ElGamal:
+            cs = ElGamal(keys=keys, key_size=key_size)
+        elif algorithm_name == Algorithm.ExponentialElGamal:
+            cs = ElGamal(keys=keys, key_size=key_size, exponential=True)
+        elif algorithm_name == Algorithm.EllipticCurveElGamal:
+            cs = EllipticCurveElGamal(keys=keys, key_size=key_size)
+        elif algorithm_name == Algorithm.Paillier:
+            cs = Paillier(keys=keys, key_size=key_size)
+        elif algorithm_name == Algorithm.DamgardJurik:
+            cs = DamgardJurik(keys=keys, key_size=key_size)
+        elif algorithm_name == Algorithm.OkamotoUchiyama:
+            cs = OkamotoUchiyama(keys=keys, key_size=key_size)
+        elif algorithm_name == Algorithm.Benaloh:
+            cs = Benaloh(keys=keys, key_size=key_size)
+        elif algorithm_name == Algorithm.NaccacheStern:
+            cs = NaccacheStern(keys=keys, key_size=key_size)
+        elif algorithm_name == Algorithm.GoldwasserMicali:
+            cs = GoldwasserMicali(keys=keys, key_size=key_size)
+        else:
+            raise ValueError(f"unimplemented algorithm - {algorithm_name}")
+        return cs
+
+    def encrypt(self, plaintext: int) -> Ciphertext:
+        """
+        Encrypt a plaintext with a built cryptosystem
+        Args:
+            plaintext (int): message
+        Returns
+            ciphertext (from lightphe.models.Ciphertext import Ciphertext): encrypted message
+        """
+        ciphertext = self.cs.encrypt(plaintext=plaintext)
+        return Ciphertext(algorithm_name=self.algorithm_name, keys=self.cs.keys, value=ciphertext)
+
+    def decrypt(self, ciphertext: Ciphertext) -> int:
+        """
+        Decrypt a ciphertext with a buit cryptosystem
+        Args:
+            ciphertext (from lightphe.models.Ciphertext import Ciphertext): encrypted message
+        Returns:
+            plaintext (int): restored message
+        """
+        return self.cs.decrypt(ciphertext=ciphertext.value)
+
+    def regenerate_ciphertext(self, ciphertext: Ciphertext) -> Ciphertext:
+        """
+        Generate a different ciphertext belonging to same plaintext
+        Args:
+            ciphertext (from lightphe.models.Ciphertext import Ciphertext): encrypted message
+        Returns:
+            ciphertext (from lightphe.models.Ciphertext import Ciphertext): encrypted message
+        """
+        ciphertext_new = self.cs.reencrypt(ciphertext=ciphertext.value)
+        return Ciphertext(
+            algorithm_name=self.algorithm_name, keys=self.cs.keys, value=ciphertext_new
+        )
+
+    def export_keys(self, target_file: str, public: bool = False) -> None:
+        """
+        Export keys to a file
+        Args:
+            target_file (str): target file name
+            public (bool): set this to True if you will publish this
+                to publicly.
+        """
+        keys = self.cs.keys
+        if public is True and keys.get("private_key") is not None:
+            del keys["private_key"]
+
+        if public is False:
+            logger.warn(
+                "You did not set public arg to True. So, exported key has private key information."
+                "Do not share this to anyone"
+            )
+
+        with open(target_file, "w", encoding="UTF-8") as file:
+            file.write(json.dumps(keys))
+
+    def restore_keys(self, target_file: str) -> dict:
+        """
+        Restore keys from a file
+        Args:
+            target_file (str): target file name
+        Returns:
+            keys (dict): private public key pair
+        """
+        with open(target_file, "r", encoding="UTF-8") as file:
+            dict_str = file.read()
+
+        keys = eval(dict_str)
+        if not isinstance(keys, dict):
+            raise ValueError(
+                f"The content of the file {target_file} does not represent a valid dictionary."
+            )
+
+        if "private_key" in keys.keys():
+            logger.info(f"private-public key pair is restored from {target_file}")
+        elif "public_key" in keys.keys():
+            logger.info(f"public key is restored from {target_file}")
+        else:
+            raise ValueError(f"File {target_file} must have public_key key")
+        return keys
+
+    def recommend_key_size(self, algorithm_name: str) -> int:
+        """
+        Recommend a key size in bits if it is not mentioned by the user
+        Args:
+            algorithm_name (str): algorithm name
+        Returns
+            key_size (int)
+        """
+        if algorithm_name == Algorithm.RSA:
+            key_size = 1024
+        elif algorithm_name == Algorithm.ElGamal:
+            key_size = 1024
+        elif algorithm_name == Algorithm.ExponentialElGamal:
+            key_size = 1024
+        # 160-bit ECC is equivalent to 1024-bit RSA
+        elif algorithm_name == Algorithm.EllipticCurveElGamal:
+            key_size = 160
+        elif algorithm_name == Algorithm.Paillier:
+            key_size = 1024
+        elif algorithm_name == Algorithm.DamgardJurik:
+            key_size = 1024
+        elif algorithm_name == Algorithm.OkamotoUchiyama:
+            key_size = 1024
+        # n should be several hundred bits or more
+        elif algorithm_name == Algorithm.GoldwasserMicali:
+            key_size = 100
+        # Benaloh and Naccache-Stern require to solve DLP in decryption
+        # so small key is recommended
+        elif algorithm_name == Algorithm.Benaloh:
+            key_size = 50
+        elif algorithm_name == Algorithm.NaccacheStern:
+            key_size = 37
+        else:
+            raise ValueError(f"unimplemented algorithm - {algorithm_name}")
+        return key_size

lightphe-0.0.2/lightphe/commons/logger.py

@@ -0,0 +1,39 @@
+import os
+import logging
+from datetime import datetime
+
+
+class Logger:
+    def __init__(self):
+        log_level = os.environ.get("LIGHTPHE_LOG_LEVEL", str(logging.INFO))
+        try:
+            self.log_level = int(log_level)
+        except Exception as err:
+            self.dump_log(
+                f"Exception while parsing $LIGHTPHE_LOG_LEVEL."
+                f"Expected int but it is {log_level} ({str(err)})"
+            )
+            self.log_level = logging.INFO
+
+    def debug(self, message):
+        if self.log_level <= logging.DEBUG:
+            self.dump_log(message)
+
+    def info(self, message):
+        if self.log_level <= logging.INFO:
+            self.dump_log(message)
+
+    def warn(self, message):
+        if self.log_level <= logging.WARNING:
+            self.dump_log(message)
+
+    def error(self, message):
+        if self.log_level <= logging.ERROR:
+            self.dump_log(message)
+
+    def critical(self, message):
+        if self.log_level <= logging.CRITICAL:
+            self.dump_log(message)
+
+    def dump_log(self, message):
+        print(f"{str(datetime.now())[2:-7]} - {message}")

lightphe-0.0.2/lightphe/cryptosystems/Benaloh.py

@@ -0,0 +1,208 @@
+import random
+from math import gcd
+from typing import Optional
+import sympy
+from lightphe.models.Homomorphic import Homomorphic
+from lightphe.commons.logger import Logger
+
+logger = Logger()
+
+
+class Benaloh(Homomorphic):
+    def __init__(self, keys: Optional[dict] = None, key_size: int = 50):
+        """
+        Args:
+            keys (dict): private - public key pair.
+                set this to None if you want to generate random keys.
+            key_size (int): key size in bits. default is less than other cryptosystems
+                because decryption of Benaloh requires to solve DLP :/
+        """
+        self.keys = keys or self.generate_keys(key_size)
+        self.plaintext_modulo = self.keys["public_key"]["r"]
+        self.ciphertext_modulo = self.keys["public_key"]["n"]
+
+    def generate_keys(self, key_size: int) -> dict:
+        """
+        Generate public and private keys of Paillier cryptosystem
+        Args:
+            key_size (int): key size in bits
+        Returns:
+            keys (dict): having private_key and public_key keys
+        """
+        keys = {}
+        keys["private_key"] = {}
+        keys["public_key"] = {}
+
+        x = 1
+        while x == 1:
+            # picking a prime p
+            p = sympy.randprime(200, 2**key_size)
+
+            # picking a prime q
+            q = sympy.randprime(100, p)
+
+            n = p * q
+            phi = (p - 1) * (q - 1)
+
+            r = p - 1
+            while gcd(q - 1, r) != 1:
+                r = int(r / gcd(q - 1, r))
+
+            if not (
+                # r should divide p-1 without remainder
+                (p - 1) % r == 0
+                # r and (p - 1) / r must be coprimes
+                and gcd(r, int((p - 1) / r)) == 1
+                # r and q-1 must be coprimes
+                and gcd(r, q - 1) == 1
+            ):
+                continue
+
+            y = random.randint(2, n)
+            if gcd(y, n) != 1:
+                continue
+
+            # to guarantee correct decryption
+            prime_factors = sympy.factorint(r).keys()
+            decryption_guaranteed = True
+            for prime_factor in prime_factors:
+                # none of r's prime factor should satisfy the condition
+                if pow(y, int(phi / prime_factor), n) == 1:
+                    decryption_guaranteed = False
+
+            if decryption_guaranteed is False:
+                continue
+
+            x = pow(y, int(phi / r), n)
+            if x != 1:
+                break
+
+        keys["public_key"]["y"] = y
+        keys["public_key"]["r"] = r
+        keys["public_key"]["n"] = n
+
+        keys["private_key"]["p"] = p
+        keys["private_key"]["q"] = q
+        keys["private_key"]["phi"] = phi
+        keys["private_key"]["x"] = x
+
+        return keys
+
+    def generate_random_key(self) -> int:
+        """
+        Generate random key for encryption
+        """
+        n = self.keys["public_key"]["n"]
+        while True:
+            u = random.randint(1, n)
+            if gcd(u, n) == 1:
+                break
+        return u
+
+    def encrypt(self, plaintext: int, random_key: Optional[int] = None) -> int:
+        """
+        Encrypt a given plaintext for optionally given random key with Benaloh
+        Args:
+            plaintext (int): message to encrypt
+            random_key (int): Benaloh requires a random key
+                Random key will be generated automatically if you do not set this.
+        Returns:
+            ciphertext (int): encrypted message
+        """
+        y = self.keys["public_key"]["y"]
+        r = self.keys["public_key"]["r"]
+        n = self.keys["public_key"]["n"]
+
+        u = random_key or self.generate_random_key()
+
+        if plaintext > r:
+            plaintext = plaintext % r
+            logger.debug(
+                f"Benaloh lets you to encrypt messages in [0, {r=}]."
+                f"But your plaintext exceeds this limit."
+                f"New plaintext is {plaintext}"
+            )
+
+        c = (pow(y, plaintext, n) * pow(u, r, n)) % n
+
+        if gcd(c, n) != 1:
+            logger.debug("ciphertext is not co-prime with n!")
+
+        return c
+
+    def decrypt(self, ciphertext: int) -> int:
+        """
+        Decrypt a given ciphertext with Benaloh
+        Args:
+            ciphertext (int): encrypted message
+        Returns:
+            plaintext (int): restored message
+        """
+        n = self.keys["public_key"]["n"]
+        r = self.keys["public_key"]["r"]
+        phi = self.keys["private_key"]["phi"]
+        x = self.keys["private_key"]["x"]
+
+        a = pow(ciphertext, int(phi / r), n)
+
+        md = 0
+        while True:
+            if pow(x, md, n) == a:
+                break
+            md = md + 1
+            if md > r:
+                raise ValueError(f"Message cannot be restored in [{0}, {n}]")
+        return md
+
+    def add(self, ciphertext1: int, ciphertext2: int) -> int:
+        """
+        Perform homomorphic addition on encrypted data.
+        Result of this must be equal to E(m1 + m2)
+        Encryption calculations are done in module n
+        Args:
+            ciphertext1 (int): 1st ciphertext created with Benaloh
+            ciphertext2 (int): 2nd ciphertext created with Benaloh
+        Returns:
+            ciphertext3 (int): 3rd ciphertext created with Benaloh
+        """
+        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.
+        Result of this must be equal to E(m1 * constant) where E(m1) = ciphertext
+        Encryption calculations are done in module n squared.
+        Args:
+            ciphertext (int): ciphertext created with Benaloh
+            constant (int): known plain constant
+        Returns:
+            ciphertext (int): new ciphertext created with Benaloh
+        """
+        # raise ValueError("Benaloh is not supporting multiplying by a constant")
+        n = self.keys["public_key"]["n"]
+        if constant > self.plaintext_modulo:
+            constant = constant % self.plaintext_modulo
+            logger.debug(
+                f"Benaloh can encrypt messages [1, {self.plaintext_modulo}]. "
+                f"Seems constant exceeded this limit. New constant is {constant}"
+            )
+        return pow(ciphertext, constant, n)
+
+    def reencrypt(self, ciphertext: int) -> int:
+        """
+        Re-generate ciphertext with re-encryption. Many ciphertext will be decrypted to same plaintext.
+        Args:
+            ciphertext (int): given ciphertext
+        Returns:
+            new ciphertext (int): different ciphertext for same plaintext
+        """
+        neutral_element = 0
+        neutral_encrypted = self.encrypt(plaintext=neutral_element)
+        return self.add(ciphertext1=ciphertext, ciphertext2=neutral_encrypted)