lightphe 0.0.4__tar.gz → 0.0.6__tar.gz

{lightphe-0.0.4 → lightphe-0.0.6}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: lightphe
-Version: 0.0.4
+Version: 0.0.6
 Summary: A Lightweight Partially Homomorphic Encryption Library for Python
 Home-page: https://github.com/serengil/LightPHE
 Author: Sefik Ilkin Serengil
@@ -19,7 +19,7 @@ License-File: LICENSE
 <div align="center">
 
 [![PyPI Downloads](https://static.pepy.tech/personalized-badge/lightphe?period=total&units=international_system&left_color=grey&right_color=blue&left_text=pypi%20downloads)](https://pepy.tech/project/lightphe)
-[![Stars](https://img.shields.io/github/stars/serengil/LightPHE?color=yellow&style=flat)](https://github.com/serengil/LightPHE/stargazers)
+[![Stars](https://img.shields.io/github/stars/serengil/LightPHE?color=yellow&style=flat&label=%E2%AD%90%20stars)](https://github.com/serengil/LightPHE/stargazers)
 [![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)
 [![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)
@@ -41,7 +41,8 @@ Even though fully homomorphic encryption (FHE) has become available in recent ti
 
 - 🏎️ Notably faster
 - 💻 Demands fewer computational resources
-- 📏 Generating smaller ciphertexts
+- 📏 Generating much smaller ciphertexts
+- 🔑 Distributing much smaller keys
 - 🧠 Well-suited for memory-constrained environments
 - ⚖️ Strikes a favorable balance for practical use cases
 
@@ -173,6 +174,51 @@ with pytest.raises(ValueError, match="Paillier is not homomorphic with respect t
 
 However, if you tried to multiply ciphertexts with RSA, or xor ciphertexts with Goldwasser-Micali, these will be succeeded because those cryptosystems support those homomorphic operations.
 
+# Working with vectors
+
+You can encrypt the output vectors of machine learning models with LightPHE. These encrypted tensors come with homomorphic operation support including homomorphic addition, element-wise multiplication and scalar multiplication.
+
+```python
+# build an additively homomorphic cryptosystem
+cs = LightPHE(algorithm_name="Paillier")
+
+# define plain tensors
+t1 = [1.005, 2.05, 3.5, 4]
+t2 = [5, 6.2, 7.002, 8.02]
+
+# encrypt tensors
+c1 = cs.encrypt(t1)
+c2 = cs.encrypt(t2)
+
+# perform homomorphic addition
+c3 = c1 + c2
+
+# perform homomorphic element-wise multiplication
+c4 = c1 * c2
+
+# perform homomorphic scalar multiplication
+k = 5
+c5 = k * c1
+
+# decrypt the addition tensor
+t3 = cs.decrypt(c3)
+
+# decrypt the element-wise multiplied tensor
+t4 = cs.decrypt(c4)
+
+# decrypt the scalar multiplied tensor
+t5 = cs.decrypt(c5)
+
+# data validations
+threshold = 0.5
+for i in range(0, len(t1)):
+   assert abs((t1[i] + t2[i]) - t3[i]) < threshold
+   assert abs((t1[i] * t2[i]) - t4[i]) < threshold
+   assert abs((t1[i] * k) - t5[i]) < threshold
+```
+
+Unfortunately, vector multiplication (dot product) requires both homomorphic addition and homomorphic multiplication and this cannot be done with partially homomorphic encryption algorithms.
+
 # 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.

{lightphe-0.0.4 → lightphe-0.0.6}/README.md

@@ -3,7 +3,7 @@
 <div align="center">
 
 [![PyPI Downloads](https://static.pepy.tech/personalized-badge/lightphe?period=total&units=international_system&left_color=grey&right_color=blue&left_text=pypi%20downloads)](https://pepy.tech/project/lightphe)
-[![Stars](https://img.shields.io/github/stars/serengil/LightPHE?color=yellow&style=flat)](https://github.com/serengil/LightPHE/stargazers)
+[![Stars](https://img.shields.io/github/stars/serengil/LightPHE?color=yellow&style=flat&label=%E2%AD%90%20stars)](https://github.com/serengil/LightPHE/stargazers)
 [![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)
 [![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)
@@ -25,7 +25,8 @@ Even though fully homomorphic encryption (FHE) has become available in recent ti
 
 - 🏎️ Notably faster
 - 💻 Demands fewer computational resources
-- 📏 Generating smaller ciphertexts
+- 📏 Generating much smaller ciphertexts
+- 🔑 Distributing much smaller keys
 - 🧠 Well-suited for memory-constrained environments
 - ⚖️ Strikes a favorable balance for practical use cases
 
@@ -157,6 +158,51 @@ with pytest.raises(ValueError, match="Paillier is not homomorphic with respect t
 
 However, if you tried to multiply ciphertexts with RSA, or xor ciphertexts with Goldwasser-Micali, these will be succeeded because those cryptosystems support those homomorphic operations.
 
+# Working with vectors
+
+You can encrypt the output vectors of machine learning models with LightPHE. These encrypted tensors come with homomorphic operation support including homomorphic addition, element-wise multiplication and scalar multiplication.
+
+```python
+# build an additively homomorphic cryptosystem
+cs = LightPHE(algorithm_name="Paillier")
+
+# define plain tensors
+t1 = [1.005, 2.05, 3.5, 4]
+t2 = [5, 6.2, 7.002, 8.02]
+
+# encrypt tensors
+c1 = cs.encrypt(t1)
+c2 = cs.encrypt(t2)
+
+# perform homomorphic addition
+c3 = c1 + c2
+
+# perform homomorphic element-wise multiplication
+c4 = c1 * c2
+
+# perform homomorphic scalar multiplication
+k = 5
+c5 = k * c1
+
+# decrypt the addition tensor
+t3 = cs.decrypt(c3)
+
+# decrypt the element-wise multiplied tensor
+t4 = cs.decrypt(c4)
+
+# decrypt the scalar multiplied tensor
+t5 = cs.decrypt(c5)
+
+# data validations
+threshold = 0.5
+for i in range(0, len(t1)):
+   assert abs((t1[i] + t2[i]) - t3[i]) < threshold
+   assert abs((t1[i] * t2[i]) - t4[i]) < threshold
+   assert abs((t1[i] * k) - t5[i]) < threshold
+```
+
+Unfortunately, vector multiplication (dot product) requires both homomorphic addition and homomorphic multiplication and this cannot be done with partially homomorphic encryption algorithms.
+
 # 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.

{lightphe-0.0.4 → lightphe-0.0.6}/lightphe/__init__.py

@@ -1,8 +1,10 @@
 import json
-from typing import Optional, Union
+from typing import Optional, Union, List
 
+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.cryptosystems.RSA import RSA
 from lightphe.cryptosystems.ElGamal import ElGamal
 from lightphe.cryptosystems.Paillier import Paillier
@@ -12,12 +14,12 @@ 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 import calculations
+from lightphe.commons import phe_utils
 from lightphe.commons.logger import Logger
 
-# pylint: disable=eval-used
+# pylint: disable=eval-used, simplifiable-if-expression
 
-logger = Logger()
+logger = Logger(module="lightphe/__init__.py")
 
 
 class LightPHE:
@@ -27,6 +29,7 @@ class LightPHE:
         keys: Optional[dict] = None,
         key_file: Optional[str] = None,
         key_size: Optional[int] = None,
+        precision: int = 5,
     ):
         """
         Build LightPHE class
@@ -37,17 +40,19 @@ class LightPHE:
             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
+            precision (int): precision for homomorphic operations on tensors
         """
         self.algorithm_name = algorithm_name
+        self.precision = precision
 
         if key_file is not None:
             keys = self.restore_keys(target_file=key_file)
 
-        self.cs = self.build_cryptosystem(
+        self.cs: Homomorphic = self.__build_cryptosystem(
             algorithm_name=algorithm_name, keys=keys, key_size=key_size
         )
 
-    def build_cryptosystem(
+    def __build_cryptosystem(
         self,
         algorithm_name: str,
         keys: Optional[dict] = None,
@@ -103,22 +108,29 @@ class LightPHE:
             raise ValueError(f"unimplemented algorithm - {algorithm_name}")
         return cs
 
-    def encrypt(self, plaintext: Union[int, float]) -> Ciphertext:
+    def encrypt(self, plaintext: Union[int, float, list]) -> Union[Ciphertext, EncryptedTensor]:
         """
         Encrypt a plaintext with a built cryptosystem
         Args:
-            plaintext (int or float): message
+            plaintext (int, float or tensor): message
         Returns
             ciphertext (from lightphe.models.Ciphertext import Ciphertext): encrypted message
         """
+        if self.cs.keys.get("public_key") is None:
+            raise ValueError("You must have public key to perform encryption")
+
+        if isinstance(plaintext, list):
+            # then encrypt tensors
+            return self.__encrypt_tensors(tensor=plaintext)
+
         ciphertext = self.cs.encrypt(
-            plaintext=calculations.parse_int(
-                value=plaintext, modulo=self.cs.modulo or self.cs.plaintext_modulo
-            )
+            plaintext=phe_utils.parse_int(value=plaintext, modulo=self.cs.plaintext_modulo)
         )
         return Ciphertext(algorithm_name=self.algorithm_name, keys=self.cs.keys, value=ciphertext)
 
-    def decrypt(self, ciphertext: Ciphertext) -> int:
+    def decrypt(
+        self, ciphertext: Union[Ciphertext, EncryptedTensor]
+    ) -> Union[int, List[int], List[float]]:
         """
         Decrypt a ciphertext with a buit cryptosystem
         Args:
@@ -126,8 +138,89 @@ class LightPHE:
         Returns:
             plaintext (int): restored message
         """
+        if self.cs.keys.get("private_key") is None:
+            raise ValueError("You must have private key to perform decryption")
+
+        if self.cs.keys.get("public_key") is None:
+            raise ValueError("You must have public key to perform decryption")
+
+        if isinstance(ciphertext, EncryptedTensor):
+            # then this is encrypted tensor
+            return self.__decrypt_tensors(encrypted_tensor=ciphertext)
+
         return self.cs.decrypt(ciphertext=ciphertext.value)
 
+    def __encrypt_tensors(self, tensor: list) -> EncryptedTensor:
+        """
+        Encrypt a given tensor
+        Args:
+            tensor (list of int or float)
+        Returns
+            encrypted tensor (list of encrypted tensor object)
+        """
+        encrypted_tensor: List[Fraction] = []
+        for m in tensor:
+            if isinstance(m, int):
+                dividend_encrypted = self.cs.encrypt(
+                    plaintext=(m % self.cs.plaintext_modulo) * pow(10, self.precision)
+                )
+                abs_dividend_encrypted = self.cs.encrypt(
+                    plaintext=(abs(m) % self.cs.plaintext_modulo) * pow(10, self.precision)
+                )
+                divisor_encrypted = self.cs.encrypt(plaintext=pow(10, self.precision))
+                c = Fraction(
+                    dividend=dividend_encrypted,
+                    divisor=divisor_encrypted,
+                    abs_dividend=abs_dividend_encrypted,
+                    sign=1 if m >= 0 else -1,
+                )
+            elif isinstance(m, float):
+                dividend, divisor = phe_utils.fractionize(
+                    value=(m % self.cs.plaintext_modulo),
+                    modulo=self.cs.plaintext_modulo,
+                    precision=self.precision,
+                )
+                abs_dividend, _ = phe_utils.fractionize(
+                    value=(abs(m) % self.cs.plaintext_modulo),
+                    modulo=self.cs.plaintext_modulo,
+                    precision=self.precision,
+                )
+                dividend_encrypted = self.cs.encrypt(plaintext=dividend)
+                abs_dividend_encrypted = self.cs.encrypt(plaintext=abs_dividend)
+                divisor_encrypted = self.cs.encrypt(plaintext=divisor)
+                c = Fraction(
+                    dividend=dividend_encrypted,
+                    divisor=divisor_encrypted,
+                    abs_dividend=abs_dividend_encrypted,
+                    sign=1 if m >= 0 else -1,
+                )
+            else:
+                raise ValueError(f"unimplemented type - {type(m)}")
+            encrypted_tensor.append(c)
+        return EncryptedTensor(fractions=encrypted_tensor, cs=self.cs)
+
+    def __decrypt_tensors(self, encrypted_tensor: EncryptedTensor) -> Union[List[int], List[float]]:
+        """
+        Decrypt a given encrypted tensor
+        Args:
+            encrypted_tensor (list of encrypted tensor)
+        Returns:
+            List of plain tensors
+        """
+        plain_tensor = []
+        for c in encrypted_tensor.fractions:
+            if isinstance(c, Fraction) is False:
+                raise ValueError("Ciphertext items must be type of Fraction")
+
+            sign = c.sign
+            abs_dividend = self.cs.decrypt(ciphertext=c.abs_dividend)
+            # dividend = self.cs.decrypt(ciphertext=c.dividend)
+            divisor = self.cs.decrypt(ciphertext=c.divisor)
+            m = sign * abs_dividend / divisor
+
+            plain_tensor.append(m)
+        return plain_tensor
+
     def regenerate_ciphertext(self, ciphertext: Ciphertext) -> Ciphertext:
         """
         Generate a different ciphertext belonging to same plaintext
@@ -136,6 +229,9 @@ class LightPHE:
         Returns:
             ciphertext (from lightphe.models.Ciphertext import Ciphertext): encrypted message
         """
+        if self.cs.keys.get("private_key") is None:
+            raise ValueError("You must have private key to perform decryption")
+
         ciphertext_new = self.cs.reencrypt(ciphertext=ciphertext.value)
         return Ciphertext(
             algorithm_name=self.algorithm_name, keys=self.cs.keys, value=ciphertext_new
@@ -150,7 +246,9 @@ class LightPHE:
                 to publicly.
         """
         keys = self.cs.keys
+        private_key = None
         if public is True and keys.get("private_key") is not None:
+            private_key = keys["private_key"]
             del keys["private_key"]
 
         if public is False:
@@ -162,6 +260,10 @@ class LightPHE:
         with open(target_file, "w", encoding="UTF-8") as file:
             file.write(json.dumps(keys))
 
+        # restore private key if you dropped
+        if private_key is not None:
+            self.cs.keys["private_key"] = private_key
+
     def restore_keys(self, target_file: str) -> dict:
         """
         Restore keys from a file

{lightphe-0.0.4 → lightphe-0.0.6}/lightphe/commons/logger.py

@@ -6,7 +6,8 @@ from datetime import datetime
 
 
 class Logger:
-    def __init__(self):
+    def __init__(self, module):
+        self.module = module
         log_level = os.environ.get("LIGHTPHE_LOG_LEVEL", str(logging.INFO))
         try:
             self.log_level = int(log_level)

lightphe-0.0.6/lightphe/commons/phe_utils.py

@@ -0,0 +1,58 @@
+from typing import Union, Tuple, Optional
+from decimal import Decimal, getcontext
+from lightphe.commons.logger import Logger
+
+logger = Logger(module="lightphe/commons/phe_utils.py")
+
+# pylint: disable=no-else-return, no-else-break
+
+
+def parse_int(value: Union[int, float], modulo: int) -> int:
+    if isinstance(value, int):
+        result = value % modulo
+    elif isinstance(value, float) and value >= 0:
+        dividend, divisor = fractionize(value=value, modulo=modulo)
+        logger.debug(f"{dividend}*{divisor}^-1 mod {modulo}")
+        result = (dividend * pow(divisor, -1, modulo)) % modulo
+    elif isinstance(value, float) and value < 0:
+        # TODO: think and implement this later
+        raise ValueError("Case constant float and negative not implemented yet")
+    else:
+        raise ValueError(f"Unimplemented case for constant type {type(value)}")
+
+    return result
+
+
+def fractionize(value: float, modulo: int, precision: Optional[int] = None) -> Tuple[int, int]:
+    getcontext().prec = 50
+
+    if precision is None:
+        decimal_places = len(str(value).split(".")[1])
+        scaling_factor = 10**decimal_places
+    else:
+        scaling_factor = 10**precision
+
+    while True:
+        integer_value = int(Decimal(value) * Decimal(scaling_factor)) % modulo
+
+        if precision is None:
+            break
+
+        if scaling_factor > 10**precision:
+            # If scaling factor is too large, discard excess part of integer value
+            integer_value = int(integer_value / (10 ** (scaling_factor - 10**precision)))
+            break
+        elif scaling_factor < 10 ** (precision - 1):
+            # If scaling factor is too small, multiply dividend and divisor 10 times
+            value *= 10
+            scaling_factor *= 10
+        else:
+            break
+
+    logger.debug(f"{integer_value}*{scaling_factor}^-1 mod {modulo}")
+    return integer_value, scaling_factor
+
+
+def solve_dlp():
+    # TODO: implement this later
+    pass

{lightphe-0.0.4 → lightphe-0.0.6}/lightphe/cryptosystems/Benaloh.py

@@ -5,7 +5,7 @@ import sympy
 from lightphe.models.Homomorphic import Homomorphic
 from lightphe.commons.logger import Logger
 
-logger = Logger()
+logger = Logger(module="lightphe/cryptosystems/Benaloh.py")
 
 
 class Benaloh(Homomorphic):

{lightphe-0.0.4 → lightphe-0.0.6}/lightphe/cryptosystems/DamgardJurik.py

@@ -5,7 +5,7 @@ import sympy
 from lightphe.models.Homomorphic import Homomorphic
 from lightphe.commons.logger import Logger
 
-logger = Logger()
+logger = Logger(module="lightphe/cryptosystems/DamgardJurik.py")
 
 
 class DamgardJurik(Homomorphic):

{lightphe-0.0.4 → lightphe-0.0.6}/lightphe/cryptosystems/ElGamal.py

@@ -5,7 +5,7 @@ import sympy
 from lightphe.models.Homomorphic import Homomorphic
 from lightphe.commons.logger import Logger
 
-logger = Logger()
+logger = Logger(module="lightphe/cryptosystems/ElGamal.py")
 
 
 class ElGamal(Homomorphic):
@@ -26,7 +26,8 @@ class ElGamal(Homomorphic):
         """
         self.exponential = exponential
         self.keys = keys or self.generate_keys(key_size)
-        self.modulo = self.keys["public_key"]["p"]
+        self.plaintext_modulo = self.keys["public_key"]["p"]
+        self.ciphertext_modulo = self.keys["public_key"]["p"]
 
     def generate_keys(self, key_size: int):
         """

{lightphe-0.0.4 → lightphe-0.0.6}/lightphe/cryptosystems/EllipticCurveElGamal.py

@@ -4,7 +4,7 @@ from lightphe.models.Homomorphic import Homomorphic
 from lightphe.elliptic.Weierstrass import Weierstrass
 from lightphe.commons.logger import Logger
 
-logger = Logger()
+logger = Logger(module="lightphe/cryptosystems/EllipticCurveElGamal.py")
 
 
 class EllipticCurveElGamal(Homomorphic):
@@ -27,7 +27,8 @@ class EllipticCurveElGamal(Homomorphic):
         # TODO: add different forms and curves. e.g. Koblitz, Edwards (Ed25519)
         self.curve = Weierstrass()
         self.keys = keys or self.generate_keys(key_size)
-        self.modulo = self.curve.p
+        self.plaintext_modulo = self.curve.p
+        self.ciphertext_modulo = self.curve.p
 
     def generate_keys(self, key_size: int):
         """

{lightphe-0.0.4 → lightphe-0.0.6}/lightphe/cryptosystems/GoldwasserMicali.py

@@ -6,7 +6,7 @@ from sympy import jacobi_symbol
 from lightphe.models.Homomorphic import Homomorphic
 from lightphe.commons.logger import Logger
 
-logger = Logger()
+logger = Logger(module="lightphe/cryptosystems/GoldwasserMicali.py")
 
 # pylint:disable=consider-using-enumerate
 
@@ -26,6 +26,8 @@ class GoldwasserMicali(Homomorphic):
         """
         self.keys = keys or self.generate_keys(key_size)
         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:
         """

{lightphe-0.0.4 → lightphe-0.0.6}/lightphe/cryptosystems/NaccacheStern.py

@@ -6,7 +6,7 @@ from sympy.ntheory.modular import solve_congruence
 from lightphe.models.Homomorphic import Homomorphic
 from lightphe.commons.logger import Logger
 
-logger = Logger()
+logger = Logger(module="lightphe/cryptosystems/NaccacheStern.py")
 
 # pylint: disable=simplifiable-if-expression, consider-using-enumerate
 

{lightphe-0.0.4 → lightphe-0.0.6}/lightphe/cryptosystems/OkamotoUchiyama.py

@@ -5,7 +5,7 @@ import sympy
 from lightphe.models.Homomorphic import Homomorphic
 from lightphe.commons.logger import Logger
 
-logger = Logger()
+logger = Logger(module="lightphe/cryptosystems/OkamotoUchiyama.py")
 
 
 class OkamotoUchiyama(Homomorphic):
@@ -81,18 +81,21 @@ class OkamotoUchiyama(Homomorphic):
         Returns:
             ciphertext (int): encrypted message
         """
-        p = self.keys["private_key"]["p"]
+
         g = self.keys["public_key"]["g"]
         n = self.keys["public_key"]["n"]
         h = self.keys["public_key"]["h"]
         r = random_key or self.generate_random_key()
 
-        if plaintext > p:
-            plaintext = plaintext % p
-            logger.debug(
-                f"plaintext must be in scale [0, {p=}] but this is exceeded."
-                "New plaintext is {plaintext}"
-            )
+        # having private key is not a must to encrypt but still if you have
+        if self.keys.get("private_key") is not None:
+            p = self.keys["private_key"]["p"]
+            if plaintext > p:
+                plaintext = plaintext % p
+                logger.debug(
+                    f"plaintext must be in scale [0, {p=}] but this is exceeded."
+                    "New plaintext is {plaintext}"
+                )
         return (pow(g, plaintext, n) * pow(h, r, n)) % n
 
     def decrypt(self, ciphertext: int):

{lightphe-0.0.4 → lightphe-0.0.6}/lightphe/cryptosystems/Paillier.py

@@ -5,7 +5,7 @@ import sympy
 from lightphe.models.Homomorphic import Homomorphic
 from lightphe.commons.logger import Logger
 
-logger = Logger()
+logger = Logger(module="lightphe/cryptosystems/Paillier.py")
 
 
 class Paillier(Homomorphic):

{lightphe-0.0.4 → lightphe-0.0.6}/lightphe/cryptosystems/RSA.py

@@ -5,7 +5,7 @@ import sympy
 from lightphe.models.Homomorphic import Homomorphic
 from lightphe.commons.logger import Logger
 
-logger = Logger()
+logger = Logger(module="lightphe/cryptosystems/RSA.py")
 
 
 class RSA(Homomorphic):
@@ -28,7 +28,8 @@ class RSA(Homomorphic):
                 and do decryption with private key d.
         """
         self.keys = keys or self.generate_keys(key_size)
-        self.modulo = self.keys["public_key"]["n"]
+        self.plaintext_modulo = self.keys["public_key"]["n"]
+        self.ciphertext_modulo = self.keys["public_key"]["n"]
         self.encrypt_with_public = encrypt_with_public
 
     def generate_keys(self, key_size: int) -> dict:

{lightphe-0.0.4 → lightphe-0.0.6}/lightphe/elliptic/Weierstrass.py

@@ -10,6 +10,7 @@ class Weierstrass(EllipticCurve):
         if curve == "secp256k1":
             self.a = 0
             self.b = 7
+            # modulo
             self.p = (
                 pow(2, 256)
                 - pow(2, 32)

{lightphe-0.0.4 → lightphe-0.0.6}/lightphe/models/Ciphertext.py

@@ -10,10 +10,10 @@ 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 import calculations
+from lightphe.commons import phe_utils
 from lightphe.commons.logger import Logger
 
-logger = Logger()
+logger = Logger(module="lightphe/models/Ciphertext.py")
 
 # pylint: disable=too-few-public-methods, no-else-return
 
@@ -63,6 +63,9 @@ class Ciphertext:
         Returns:
             ciphertext (Ciphertext): homomorphic addition of ciphertext
         """
+        if self.cs.keys.get("public_key") is None:
+            raise ValueError("You must have public key to perform homomorphic addition")
+
         result = self.cs.add(ciphertext1=self.value, ciphertext2=other.value)
         return Ciphertext(algorithm_name=self.algorithm_name, keys=self.keys, value=result)
 
@@ -74,15 +77,16 @@ class Ciphertext:
         Returns
             homomorphic multiplication of ciphertexts | scalar multiplication of ciphertext
         """
+        if self.cs.keys.get("public_key") is None:
+            raise ValueError("You must have public key to perform homomorphic multiplication")
+
         if isinstance(other, 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)
         elif isinstance(other, float):
-            constant = calculations.parse_int(
-                value=other, modulo=self.cs.modulo or self.cs.plaintext_modulo
-            )
+            constant = phe_utils.parse_int(value=other, modulo=self.cs.plaintext_modulo)
             result = self.cs.multiply_by_contant(ciphertext=self.value, constant=constant)
         else:
             raise ValueError(
@@ -98,14 +102,7 @@ class Ciphertext:
         Returns
             scalar multiplication of ciphertext
         """
-        if isinstance(constant, float):
-            constant = calculations.parse_int(
-                value=constant, modulo=self.cs.modulo or self.cs.plaintext_modulo
-            )
-
-        # Handle multiplication with a constant on the right
-        result = self.cs.multiply_by_contant(ciphertext=self.value, constant=constant)
-        return Ciphertext(algorithm_name=self.algorithm_name, keys=self.keys, value=result)
+        return self.__mul__(other=constant)
 
     def __xor__(self, other: "Ciphertext") -> "Ciphertext":
         """
@@ -115,5 +112,8 @@ class Ciphertext:
         Returns
             homomorphic xor of ciphertexts
         """
+        if self.cs.keys.get("public_key") is None:
+            raise ValueError("You must have public key to perform homomorphic xor")
+
         result = self.cs.xor(ciphertext1=self.value, ciphertext2=other.value)
         return Ciphertext(algorithm_name=self.algorithm_name, keys=self.keys, value=result)