lightphe 0.0.2__tar.gz → 0.0.3__tar.gz

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: lightphe
-Version: 0.0.2
+Version: 0.0.3
 Summary: A Lightweight Partially Homomorphic Encryption Library for Python
 Home-page: https://github.com/serengil/LightPHE
 Author: Sefik Ilkin Serengil
@@ -35,7 +35,15 @@ License-File: LICENSE
 
 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.
+# Partially vs Fully Homomorphic Encryption
+
+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.
+
+- 🏎️ Notably faster
+- 💻 Demands fewer computational resources
+- 📏 Generating smaller ciphertexts
+- 🧠 Well-suited for memory-constrained environments
+- ⚖️ Strikes a favorable balance for practical use cases
 
 # Installation [![PyPI](https://img.shields.io/pypi/v/lightphe.svg)](https://pypi.org/project/lightphe/)
 
@@ -118,18 +126,30 @@ m2 = 23
 c1 = cs.encrypt(m1)
 c2 = cs.encrypt(m2)
 
-# performing homomorphic addition on ciphertexts
-assert cs.decrypt(c1 + c2) == m1 + m2
+# homomorphic addition - private key is not required!
+c3 = c1 + c2
+
+# proof of work
+assert cs.decrypt(c3) == 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.
+⚡ Notice that once can perform `c1 + c2` here without holding private key. However, just the data owner with private key can perform encryption and decryption. This is the basic definition of homomorphic encryption.
+
+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 (increase its value 5%)
+# increasing something 5%
 k = 1.05
-assert cs.decrypt(k * c1) == k * m1
+
+# scalar multiplication - private key is not required!
+c4 = k * c1
+
+# proof of work
+assert cs.decrypt(c4) == k * m1
 ```
 
+⚡ Herein, `k * c1` operation can be performed by anyone without holding private key.
+
 Similar to the most of additively homomorphic algorithms, Paillier lets you to regenerate ciphertext while you are not breaking its plaintext restoration. You may consider to do this re-generation many times to have stronger ciphertexts.
 
 ```python
@@ -142,11 +162,11 @@ assert cs.decrypt(c1) == m1
 Finally, if you try to perform an operation that algorithm does not support, then an exception will be thrown. For instance, Paillier is not homomorphic with respect to the multiplication or xor. To put it simply, you cannot multiply two ciphertexts. If you enforce this calculation, you will have an exception.
 
 ```python
-# pailier is not homomorphic with respect to the multiplication
+# pailier is not multiplicatively homomorphic
 with pytest.raises(ValueError, match="Paillier is not homomorphic with respect to the multiplication"):
   c1 * c2
 
-# pailier is not homomorphic with respect to the xor
+# pailier is not exclusively homomorphic
 with pytest.raises(ValueError, match="Paillier is not homomorphic with respect to the exclusive or"):
   c1 ^ c2
 ```

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

@@ -19,7 +19,15 @@
 
 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.
+# Partially vs Fully Homomorphic Encryption
+
+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.
+
+- 🏎️ Notably faster
+- 💻 Demands fewer computational resources
+- 📏 Generating smaller ciphertexts
+- 🧠 Well-suited for memory-constrained environments
+- ⚖️ Strikes a favorable balance for practical use cases
 
 # Installation [![PyPI](https://img.shields.io/pypi/v/lightphe.svg)](https://pypi.org/project/lightphe/)
 
@@ -102,18 +110,30 @@ m2 = 23
 c1 = cs.encrypt(m1)
 c2 = cs.encrypt(m2)
 
-# performing homomorphic addition on ciphertexts
-assert cs.decrypt(c1 + c2) == m1 + m2
+# homomorphic addition - private key is not required!
+c3 = c1 + c2
+
+# proof of work
+assert cs.decrypt(c3) == 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.
+⚡ Notice that once can perform `c1 + c2` here without holding private key. However, just the data owner with private key can perform encryption and decryption. This is the basic definition of homomorphic encryption.
+
+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 (increase its value 5%)
+# increasing something 5%
 k = 1.05
-assert cs.decrypt(k * c1) == k * m1
+
+# scalar multiplication - private key is not required!
+c4 = k * c1
+
+# proof of work
+assert cs.decrypt(c4) == k * m1
 ```
 
+⚡ Herein, `k * c1` operation can be performed by anyone without holding private key.
+
 Similar to the most of additively homomorphic algorithms, Paillier lets you to regenerate ciphertext while you are not breaking its plaintext restoration. You may consider to do this re-generation many times to have stronger ciphertexts.
 
 ```python
@@ -126,11 +146,11 @@ assert cs.decrypt(c1) == m1
 Finally, if you try to perform an operation that algorithm does not support, then an exception will be thrown. For instance, Paillier is not homomorphic with respect to the multiplication or xor. To put it simply, you cannot multiply two ciphertexts. If you enforce this calculation, you will have an exception.
 
 ```python
-# pailier is not homomorphic with respect to the multiplication
+# pailier is not multiplicatively homomorphic
 with pytest.raises(ValueError, match="Paillier is not homomorphic with respect to the multiplication"):
   c1 * c2
 
-# pailier is not homomorphic with respect to the xor
+# pailier is not exclusively homomorphic
 with pytest.raises(ValueError, match="Paillier is not homomorphic with respect to the exclusive or"):
   c1 ^ c2
 ```

{lightphe-0.0.2/tests → lightphe-0.0.3/lightphe}/__init__.py

@@ -217,3 +217,14 @@ class LightPHE:
         else:
             raise ValueError(f"unimplemented algorithm - {algorithm_name}")
         return key_size
+
+    def create_ciphertext_obj(self, ciphertext: Union[int, tuple, list]) -> Ciphertext:
+        """
+        Ciphertext objects have keys in addition ciphertext itself to perform
+        homomorphic operations.
+        Args:
+            ciphertext (int or tuple or list): ciphertext content
+        Returns:
+            Ciphertext
+        """
+        return Ciphertext(algorithm_name=self.algorithm_name, keys=self.cs.keys, value=ciphertext)

{lightphe-0.0.2 → lightphe-0.0.3}/lightphe/models/Ciphertext.py

@@ -49,7 +49,10 @@ class Ciphertext:
         self.cs: Homomorphic = cs
 
     def __str__(self) -> str:
-        return str(self.value)
+        return f"Ciphertext({self.value})"
+
+    def __repr__(self) -> str:
+        return f"Ciphertext({self.value})"
 
     def __add__(self, other: "Ciphertext") -> "Ciphertext":
         """

{lightphe-0.0.2 → lightphe-0.0.3}/lightphe.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: lightphe
-Version: 0.0.2
+Version: 0.0.3
 Summary: A Lightweight Partially Homomorphic Encryption Library for Python
 Home-page: https://github.com/serengil/LightPHE
 Author: Sefik Ilkin Serengil
@@ -35,7 +35,15 @@ License-File: LICENSE
 
 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.
+# Partially vs Fully Homomorphic Encryption
+
+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.
+
+- 🏎️ Notably faster
+- 💻 Demands fewer computational resources
+- 📏 Generating smaller ciphertexts
+- 🧠 Well-suited for memory-constrained environments
+- ⚖️ Strikes a favorable balance for practical use cases
 
 # Installation [![PyPI](https://img.shields.io/pypi/v/lightphe.svg)](https://pypi.org/project/lightphe/)
 
@@ -118,18 +126,30 @@ m2 = 23
 c1 = cs.encrypt(m1)
 c2 = cs.encrypt(m2)
 
-# performing homomorphic addition on ciphertexts
-assert cs.decrypt(c1 + c2) == m1 + m2
+# homomorphic addition - private key is not required!
+c3 = c1 + c2
+
+# proof of work
+assert cs.decrypt(c3) == 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.
+⚡ Notice that once can perform `c1 + c2` here without holding private key. However, just the data owner with private key can perform encryption and decryption. This is the basic definition of homomorphic encryption.
+
+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 (increase its value 5%)
+# increasing something 5%
 k = 1.05
-assert cs.decrypt(k * c1) == k * m1
+
+# scalar multiplication - private key is not required!
+c4 = k * c1
+
+# proof of work
+assert cs.decrypt(c4) == k * m1
 ```
 
+⚡ Herein, `k * c1` operation can be performed by anyone without holding private key.
+
 Similar to the most of additively homomorphic algorithms, Paillier lets you to regenerate ciphertext while you are not breaking its plaintext restoration. You may consider to do this re-generation many times to have stronger ciphertexts.
 
 ```python
@@ -142,11 +162,11 @@ assert cs.decrypt(c1) == m1
 Finally, if you try to perform an operation that algorithm does not support, then an exception will be thrown. For instance, Paillier is not homomorphic with respect to the multiplication or xor. To put it simply, you cannot multiply two ciphertexts. If you enforce this calculation, you will have an exception.
 
 ```python
-# pailier is not homomorphic with respect to the multiplication
+# pailier is not multiplicatively homomorphic
 with pytest.raises(ValueError, match="Paillier is not homomorphic with respect to the multiplication"):
   c1 * c2
 
-# pailier is not homomorphic with respect to the xor
+# pailier is not exclusively homomorphic
 with pytest.raises(ValueError, match="Paillier is not homomorphic with respect to the exclusive or"):
   c1 ^ c2
 ```

{lightphe-0.0.2 → lightphe-0.0.3}/lightphe.egg-info/SOURCES.txt

@@ -28,6 +28,7 @@ lightphe/models/Homomorphic.py
 lightphe/models/__init__.py
 tests/__init__.py
 tests/test_benaloh.py
+tests/test_cloud.py
 tests/test_damgard.py
 tests/test_elgamal.py
 tests/test_ellipticcurveelgamal.py

{lightphe-0.0.2 → lightphe-0.0.3}/setup.py

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

lightphe-0.0.3/tests/test_cloud.py

@@ -0,0 +1,44 @@
+from lightphe.commons.logger import Logger
+from lightphe import LightPHE
+
+logger = Logger()
+
+# pre-generated 20-bit RSA keys
+PRIVATE = {"private_key": {"d": 30365}, "public_key": {"n": 175501, "e": 101753}}
+PUBLIC = {"public_key": {"n": 175501, "e": 101753}}
+
+
+def test_encryption():
+    cs = LightPHE(algorithm_name="RSA", keys=PRIVATE)
+
+    # plaintexts
+    m1 = 10000
+    c1 = cs.encrypt(m1)
+
+    # m2 = 1.05 # TODO: add support
+    m2 = 5
+    c2 = cs.encrypt(m2)
+
+    assert cs.decrypt(c1) == m1
+    assert cs.decrypt(c2) == m2
+
+    logger.info("✅ Cloud encryption tests done")
+
+    c3_val = homomorphic_operations(c1.value, c2.value)
+    c3 = cs.create_ciphertext_obj(c3_val)
+
+    assert cs.decrypt(c3) == m1 * m2
+
+    logger.info("✅ Cloud decryption tests done")
+
+
+def homomorphic_operations(c1: int, c2: int):
+    """
+    One can perform homomorphic operations while he/she does not hold the private key
+    """
+    cs = LightPHE(algorithm_name="RSA", keys=PUBLIC)
+    c1_obj = cs.create_ciphertext_obj(c1)
+    c2_obj = cs.create_ciphertext_obj(c2)
+    c3 = c1_obj * c2_obj
+    logger.info("✅ Cloud homomorphic operation tests done")
+    return c3.value