PyPI - lightphe - Versions diffs - 0.0.8__tar.gz → 0.0.9__tar.gz - Mend

lightphe 0.0.8tar.gz → 0.0.9tar.gz

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (52) hide show

{lightphe-0.0.8 → lightphe-0.0.9}/PKG-INFO RENAMED Viewed

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: lightphe
-Version: 0.0.8
+Version: 0.0.9
 Summary: A Lightweight Partially Homomorphic Encryption Library for Python
 Home-page: https://github.com/serengil/LightPHE
 Author: Sefik Ilkin Serengil
@@ -36,7 +36,7 @@ License-File: LICENSE
 <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/).
+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/) ([`Weierstrass`](https://sefiks.com/2016/03/13/the-math-behind-elliptic-curve-cryptography/) and [`Edwards`](https://sefiks.com/2018/12/19/a-gentle-introduction-to-edwards-curves/) forms) [`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/).
 # Partially vs Fully Homomorphic Encryption
@@ -98,7 +98,7 @@ algorithms = [
   "EllipticCurve-ElGamal"
 ]
-cs = LightPHE(algorithm_name = algorithms[0])
+phe = LightPHE(algorithm_name = algorithms[0])
 ```
 # Encryption & Decryption
@@ -110,10 +110,10 @@ Once you built your cryptosystem, you will be able to encrypt and decrypt messag
 m = 17
 # calculate ciphertext
-c = cs.encrypt(m)
+c = phe.encrypt(m)
 # proof of work
-assert cs.decrypt(c) == m
+assert phe.decrypt(c) == m
 ```
 # Homomorphic Operations
@@ -122,76 +122,90 @@ Once you have the ciphertext, you will be able to perform homomorphic operations
 ### On-Prem Encryption
-This Python code snippet demonstrates how to generate a private-public key pair using the Paillier cryptosystem via the LightPHE library. First, an instance of the LightPHE class is created with the Paillier algorithm. Then, the public key is exported and saved to a file named "public.txt" to build the same cryptosystem with only public key in the cloud side later. The code defines two plaintext values, m1 and m2, respectively. These plaintext values are encrypted to generate ciphertexts c1 and c2 using the public key. Finally, the ciphertexts c1 and c2 are prepared to be sent to a cloud system for secure processing or storage.
+This code snippet illustrates how to generate a random public-private key pair using the Paillier and encrypt a plaintext pair. The resulting ciphertext pair, c1 and c2, along with the public key, is then sent from the on-premises environment to the cloud.
 ```python
-# generate private-public key pair
-cs = LightPHE(algorithm_name = "Paillier")
-# export public key to build same cryptosystem with only public key in the cloud
-cs.export_keys(target_file = "public.txt", public = True)
-# export private key to build same cryptosystem on-prem later
-cs.export_keys(target_file = "private.txt", public = False)
-# define plaintexts
-m1 = 17
-m2 = 23
-# calculate ciphertexts
-c1 = cs.encrypt(m1).value
-c2 = cs.encrypt(m2).value
-# send c1 and c2 pair to a cloud system
+def on_premise() -> Tuple[int, int, dict]:
+    """
+    Executes on-premise operations: initializes a cryptosystem by generating
+    a random public-private key pair, then encrypts two plaintext values.
+    Returns:
+       result (tuple): A tuple containing:
+       - c1 (int): The first ciphertext
+       - c2 (int): The second ciphertext
+       - public_key (dict): The public key for the cryptosystem
+    """
+    # generate a random private-public key pair
+    phe = LightPHE(algorithm_name = "Paillier")
+    # define plaintexts
+    m1 = 10000 # base salary in usd
+    m2 = 500 # wage increase in usd
+    # calculate ciphertexts
+    c1 = phe.encrypt(m1).value
+    c2 = phe.encrypt(m2).value
+    return (c1, c2, phe.cs.public_key)
 ```
 ### Homomorphic Operations on Cloud
-This Python code snippet illustrates how to handle encrypted data on the cloud side using the Paillier cryptosystem with the LightPHE library. Upon receiving the encrypted values c1 and c2, the cloud system initializes the cryptosystem using the exported public key stored in public.txt. To ensure the security of the data, a test is performed to confirm that the cloud system cannot decrypt c1 and c2 without the private key. This is done using the pytest library, which raises a ValueError if decryption is attempted, verifying that decryption is not possible without the private key. Finally, the code demonstrates homomorphic addition by adding the two ciphertexts, resulting in a new ciphertext c3 that represents the encrypted sum of the original plaintext values.
+This code snippet demonstrates how to perform homomorphic addition on the cloud side without using the private key. However, the cloud is unable to decrypt c3 itself, even though it is the one that calculated it.
 ```python
-# cloud side receives encrypted c1 and c2
-# restore cryptosystem with the exported public key
-cs = LightPHE(algorithm_name = "Paillier", key_file = "public.txt")
-# convert c1 and c2 to ciphertext objects
-c1 = cs.create_ciphertext_obj(c1)
-c2 = cs.create_ciphertext_obj(c2)
-# confirm that cloud cannot decrypt c1
-with pytest.raises(ValueError, match="You must have private key to perform decryption"):
-  cs.decrypt(c1)
-# confirm that cloud cannot decrypt c2
-with pytest.raises(ValueError, match="You must have private key to perform decryption"):
-  cs.decrypt(c2)
-# homomorphic addition - private key not required
-c3 = c1 + c2
-# confirm that cloud cannot decrypt c3
-with pytest.raises(ValueError, match="You must have private key to perform decryption"):
-  cs.decrypt(c3)
+def cloud(c1: int, c2: int, public_key: dict) -> int:
+    """
+    Performs cloud-side operations: reconstructs a cryptosystem using the
+    provided public key and executes a homomorphic addition on two ciphertexts.
+    Args:
+       c1 (int): The first ciphertext
+       c2 (int): The second ciphertext
+       public_key (dict): The public key of an existing cryptosystem
+    Retunrs:
+       c3 (int): The resulting ciphertext after homomorphic addition
+    """
+    # restore cryptosystem with just the public key
+    phe = LightPHE(algorithm_name = "Paillier", keys = public_key)
+    # cast c1 and c2 to ciphertext objects
+    c1 = phe.create_ciphertext_obj(c1)
+    c2 = phe.create_ciphertext_obj(c2)
+    # confirm that cloud cannot decrypt c1
+    with pytest.raises(ValueError, match="You must have private key"):
+      phe.decrypt(c1)
+    # confirm that cloud cannot decrypt c2
+    with pytest.raises(ValueError, match="You must have private key"):
+      phe.decrypt(c2)
+    # perform homomorphic addition
+    c3 = c1 + c2
+    # confirm that cloud cannot decrypt c3
+    with pytest.raises(ValueError, match="You must have private key"):
+      phe.decrypt(c3)
+    return c3.value
 ```
-### On-Prem Decryption
+### On-Prem Decryption And Proof of Work
-This Python code snippet demonstrates the final step in a secure computation process using homomorphic encryption with the LightPHE library. After receiving the ciphertext c3 from the cloud, which is the result of homomorphic addition of two ciphertexts c1 and c2, the on-premises system (which has the private key) decrypts c3 to verify the result. The decrypted value is then asserted to be equal to the sum of the original plaintext values m1 and m2. This step ensures the correctness of the homomorphic computation performed by the cloud.
+This code snippet demonstrates the proof of work. Even though c3 was calculated in the cloud by adding c1 and c2, on-premises can validate that its decryption must be equal to the addition of plaintexts m1 and m2.
 ```python
-# on-prem side receives c3 from cloud
-# restore cryptosystem with the exported private key
-cs = LightPHE(algorithm_name = "Paillier", key_file = "private.txt")
 # proof of work - private key required
-assert cs.decrypt(c3) == m1 + m2
+assert phe.decrypt(c3) == m1 + m2
 ```
+In this homomorphic pipeline, the cloud's computational power was utilized to calculate c3, but it can only be decrypted by the on-premises side. Additionally, while we performed the encryption on the on-premises side, this is not strictly necessary; only the public key is required for encryption. Therefore, encryption can also be performed on the non-premises side. This approach is particularly convenient when collecting data from multiple edge devices and storing all of it in the cloud simultaneously.
 ### Scalar Multiplication
-Besides, Paillier is supporting multiplying ciphertexts by a known plain constant. This Python code snippet demonstrates how to perform scalar multiplication on encrypted data using homomorphic encryption with the LightPHE library. The factor k is set to 1.05, representing a 5% increase. On the cloud side, this factor is used to multiply the ciphertext c1, resulting in a new ciphertext c4. When the on-premises system, which holds the private key, receives c4, it decrypts it and verifies that the decrypted value matches the original plaintext m1 scaled by k (i.e., 1.05 * m1). This ensures that the homomorphic scalar multiplication was performed correctly on the encrypted data.
+Besides, Paillier is supporting multiplying ciphertexts by a known plain constant. This code snippet demonstrates how to perform scalar multiplication on encrypted data using Paillier homomorphic encryption with the LightPHE library.
 ```python
 # increasing something 5%
@@ -201,7 +215,7 @@ k = 1.05
 c4 = k * c1
 # proof of work on-prem - private key is required
-assert cs.decrypt(c4) == k * m1
+assert phe.decrypt(c4) == k * m1
 ```
 ### Ciphertext Regeneration
@@ -209,10 +223,10 @@ assert cs.decrypt(c4) == k * m1
 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
-c1_prime = cs.regenerate_ciphertext(c1)
+c1_prime = phe.regenerate_ciphertext(c1)
 assert c1_prime.value != c1.value
-assert cs.decrypt(c1_prime) == m1
-assert cs.decrypt(c1) == m1
+assert phe.decrypt(c1_prime) == m1
+assert phe.decrypt(c1) == m1
 ```
 ### Unsupported Operations
@@ -231,51 +245,6 @@ 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.8 → lightphe-0.0.9}/README.md RENAMED Viewed

@@ -20,7 +20,7 @@
 <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/).
+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/) ([`Weierstrass`](https://sefiks.com/2016/03/13/the-math-behind-elliptic-curve-cryptography/) and [`Edwards`](https://sefiks.com/2018/12/19/a-gentle-introduction-to-edwards-curves/) forms) [`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/).
 # Partially vs Fully Homomorphic Encryption
@@ -82,7 +82,7 @@ algorithms = [
   "EllipticCurve-ElGamal"
 ]
-cs = LightPHE(algorithm_name = algorithms[0])
+phe = LightPHE(algorithm_name = algorithms[0])
 ```
 # Encryption & Decryption
@@ -94,10 +94,10 @@ Once you built your cryptosystem, you will be able to encrypt and decrypt messag
 m = 17
 # calculate ciphertext
-c = cs.encrypt(m)
+c = phe.encrypt(m)
 # proof of work
-assert cs.decrypt(c) == m
+assert phe.decrypt(c) == m
 ```
 # Homomorphic Operations
@@ -106,76 +106,90 @@ Once you have the ciphertext, you will be able to perform homomorphic operations
 ### On-Prem Encryption
-This Python code snippet demonstrates how to generate a private-public key pair using the Paillier cryptosystem via the LightPHE library. First, an instance of the LightPHE class is created with the Paillier algorithm. Then, the public key is exported and saved to a file named "public.txt" to build the same cryptosystem with only public key in the cloud side later. The code defines two plaintext values, m1 and m2, respectively. These plaintext values are encrypted to generate ciphertexts c1 and c2 using the public key. Finally, the ciphertexts c1 and c2 are prepared to be sent to a cloud system for secure processing or storage.
+This code snippet illustrates how to generate a random public-private key pair using the Paillier and encrypt a plaintext pair. The resulting ciphertext pair, c1 and c2, along with the public key, is then sent from the on-premises environment to the cloud.
 ```python
-# generate private-public key pair
-cs = LightPHE(algorithm_name = "Paillier")
-# export public key to build same cryptosystem with only public key in the cloud
-cs.export_keys(target_file = "public.txt", public = True)
-# export private key to build same cryptosystem on-prem later
-cs.export_keys(target_file = "private.txt", public = False)
-# define plaintexts
-m1 = 17
-m2 = 23
-# calculate ciphertexts
-c1 = cs.encrypt(m1).value
-c2 = cs.encrypt(m2).value
-# send c1 and c2 pair to a cloud system
+def on_premise() -> Tuple[int, int, dict]:
+    """
+    Executes on-premise operations: initializes a cryptosystem by generating
+    a random public-private key pair, then encrypts two plaintext values.
+    Returns:
+       result (tuple): A tuple containing:
+       - c1 (int): The first ciphertext
+       - c2 (int): The second ciphertext
+       - public_key (dict): The public key for the cryptosystem
+    """
+    # generate a random private-public key pair
+    phe = LightPHE(algorithm_name = "Paillier")
+    # define plaintexts
+    m1 = 10000 # base salary in usd
+    m2 = 500 # wage increase in usd
+    # calculate ciphertexts
+    c1 = phe.encrypt(m1).value
+    c2 = phe.encrypt(m2).value
+    return (c1, c2, phe.cs.public_key)
 ```
 ### Homomorphic Operations on Cloud
-This Python code snippet illustrates how to handle encrypted data on the cloud side using the Paillier cryptosystem with the LightPHE library. Upon receiving the encrypted values c1 and c2, the cloud system initializes the cryptosystem using the exported public key stored in public.txt. To ensure the security of the data, a test is performed to confirm that the cloud system cannot decrypt c1 and c2 without the private key. This is done using the pytest library, which raises a ValueError if decryption is attempted, verifying that decryption is not possible without the private key. Finally, the code demonstrates homomorphic addition by adding the two ciphertexts, resulting in a new ciphertext c3 that represents the encrypted sum of the original plaintext values.
+This code snippet demonstrates how to perform homomorphic addition on the cloud side without using the private key. However, the cloud is unable to decrypt c3 itself, even though it is the one that calculated it.
 ```python
-# cloud side receives encrypted c1 and c2
-# restore cryptosystem with the exported public key
-cs = LightPHE(algorithm_name = "Paillier", key_file = "public.txt")
-# convert c1 and c2 to ciphertext objects
-c1 = cs.create_ciphertext_obj(c1)
-c2 = cs.create_ciphertext_obj(c2)
-# confirm that cloud cannot decrypt c1
-with pytest.raises(ValueError, match="You must have private key to perform decryption"):
-  cs.decrypt(c1)
-# confirm that cloud cannot decrypt c2
-with pytest.raises(ValueError, match="You must have private key to perform decryption"):
-  cs.decrypt(c2)
-# homomorphic addition - private key not required
-c3 = c1 + c2
-# confirm that cloud cannot decrypt c3
-with pytest.raises(ValueError, match="You must have private key to perform decryption"):
-  cs.decrypt(c3)
+def cloud(c1: int, c2: int, public_key: dict) -> int:
+    """
+    Performs cloud-side operations: reconstructs a cryptosystem using the
+    provided public key and executes a homomorphic addition on two ciphertexts.
+    Args:
+       c1 (int): The first ciphertext
+       c2 (int): The second ciphertext
+       public_key (dict): The public key of an existing cryptosystem
+    Retunrs:
+       c3 (int): The resulting ciphertext after homomorphic addition
+    """
+    # restore cryptosystem with just the public key
+    phe = LightPHE(algorithm_name = "Paillier", keys = public_key)
+    # cast c1 and c2 to ciphertext objects
+    c1 = phe.create_ciphertext_obj(c1)
+    c2 = phe.create_ciphertext_obj(c2)
+    # confirm that cloud cannot decrypt c1
+    with pytest.raises(ValueError, match="You must have private key"):
+      phe.decrypt(c1)
+    # confirm that cloud cannot decrypt c2
+    with pytest.raises(ValueError, match="You must have private key"):
+      phe.decrypt(c2)
+    # perform homomorphic addition
+    c3 = c1 + c2
+    # confirm that cloud cannot decrypt c3
+    with pytest.raises(ValueError, match="You must have private key"):
+      phe.decrypt(c3)
+    return c3.value
 ```
-### On-Prem Decryption
+### On-Prem Decryption And Proof of Work
-This Python code snippet demonstrates the final step in a secure computation process using homomorphic encryption with the LightPHE library. After receiving the ciphertext c3 from the cloud, which is the result of homomorphic addition of two ciphertexts c1 and c2, the on-premises system (which has the private key) decrypts c3 to verify the result. The decrypted value is then asserted to be equal to the sum of the original plaintext values m1 and m2. This step ensures the correctness of the homomorphic computation performed by the cloud.
+This code snippet demonstrates the proof of work. Even though c3 was calculated in the cloud by adding c1 and c2, on-premises can validate that its decryption must be equal to the addition of plaintexts m1 and m2.
 ```python
-# on-prem side receives c3 from cloud
-# restore cryptosystem with the exported private key
-cs = LightPHE(algorithm_name = "Paillier", key_file = "private.txt")
 # proof of work - private key required
-assert cs.decrypt(c3) == m1 + m2
+assert phe.decrypt(c3) == m1 + m2
 ```
+In this homomorphic pipeline, the cloud's computational power was utilized to calculate c3, but it can only be decrypted by the on-premises side. Additionally, while we performed the encryption on the on-premises side, this is not strictly necessary; only the public key is required for encryption. Therefore, encryption can also be performed on the non-premises side. This approach is particularly convenient when collecting data from multiple edge devices and storing all of it in the cloud simultaneously.
 ### Scalar Multiplication
-Besides, Paillier is supporting multiplying ciphertexts by a known plain constant. This Python code snippet demonstrates how to perform scalar multiplication on encrypted data using homomorphic encryption with the LightPHE library. The factor k is set to 1.05, representing a 5% increase. On the cloud side, this factor is used to multiply the ciphertext c1, resulting in a new ciphertext c4. When the on-premises system, which holds the private key, receives c4, it decrypts it and verifies that the decrypted value matches the original plaintext m1 scaled by k (i.e., 1.05 * m1). This ensures that the homomorphic scalar multiplication was performed correctly on the encrypted data.
+Besides, Paillier is supporting multiplying ciphertexts by a known plain constant. This code snippet demonstrates how to perform scalar multiplication on encrypted data using Paillier homomorphic encryption with the LightPHE library.
 ```python
 # increasing something 5%
@@ -185,7 +199,7 @@ k = 1.05
 c4 = k * c1
 # proof of work on-prem - private key is required
-assert cs.decrypt(c4) == k * m1
+assert phe.decrypt(c4) == k * m1
 ```
 ### Ciphertext Regeneration
@@ -193,10 +207,10 @@ assert cs.decrypt(c4) == k * m1
 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
-c1_prime = cs.regenerate_ciphertext(c1)
+c1_prime = phe.regenerate_ciphertext(c1)
 assert c1_prime.value != c1.value
-assert cs.decrypt(c1_prime) == m1
-assert cs.decrypt(c1) == m1
+assert phe.decrypt(c1_prime) == m1
+assert phe.decrypt(c1) == m1
 ```
 ### Unsupported Operations
@@ -215,51 +229,6 @@ 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.8 → lightphe-0.0.9}/lightphe/__init__.py RENAMED Viewed

@@ -23,6 +23,7 @@ logger = Logger(module="lightphe/__init__.py")
 class LightPHE:
+    __version__ = "0.0.9"
     def __init__(
         self,
         algorithm_name: str,
@@ -30,6 +31,7 @@ class LightPHE:
         key_file: Optional[str] = None,
         key_size: Optional[int] = None,
         precision: int = 5,
+        form: str = "weierstrass",
     ):
         """
         Build LightPHE class
@@ -41,15 +43,19 @@ class LightPHE:
             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
+            form (str): specifies the form of the elliptic curve.
+                Options: 'weierstrass' (default), 'edwards'.
+                This parameter is only used if `algorithm_name` is 'EllipticCurve-ElGamal'.
         """
         self.algorithm_name = algorithm_name
         self.precision = precision
+        self.form = form
         if key_file is not None:
             keys = self.restore_keys(target_file=key_file)
         self.cs: Homomorphic = self.__build_cryptosystem(
-            algorithm_name=algorithm_name, keys=keys, key_size=key_size
+            algorithm_name=algorithm_name, keys=keys, key_size=key_size, form=form,
         )
     def __build_cryptosystem(
@@ -57,6 +63,7 @@ class LightPHE:
         algorithm_name: str,
         keys: Optional[dict] = None,
         key_size: Optional[int] = None,
+        form: Optional[str] = None,
     ) -> Union[
         RSA,
         ElGamal,
@@ -72,17 +79,16 @@ class LightPHE:
         Args:
             algorithm_name (str): RSA | ElGamal | Exponential-ElGamal | EllipticCurve-ElGamal
                 | Paillier | Damgard-Jurik | Okamoto-Uchiyama | Benaloh | Naccache-Stern
-                | Goldwasser-Micali
+                | Goldwasser-Micali | Edwards-ElGamal
             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
+            form (str): specifies the form of the elliptic curve.
+                Options: 'weierstrass' (default), 'edwards'.
+                This parameter is only used if `algorithm_name` is 'EllipticCurve-ElGamal'.
         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)
@@ -91,7 +97,7 @@ class LightPHE:
         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)
+            cs = EllipticCurveElGamal(keys=keys, key_size=key_size, form=form)
         elif algorithm_name == Algorithm.Paillier:
             cs = Paillier(keys=keys, key_size=key_size)
         elif algorithm_name == Algorithm.DamgardJurik:
@@ -126,7 +132,7 @@ class LightPHE:
         ciphertext = self.cs.encrypt(
             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)
+        return Ciphertext(algorithm_name=self.algorithm_name, keys=self.cs.keys, value=ciphertext, form=self.form)
     def decrypt(
         self, ciphertext: Union[Ciphertext, EncryptedTensor]
@@ -289,42 +295,6 @@ class LightPHE:
             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
     def create_ciphertext_obj(self, ciphertext: Union[int, tuple, list]) -> Ciphertext:
         """
         Ciphertext objects have keys in addition ciphertext itself to perform

lightphe 0.0.8__tar.gz → 0.0.9__tar.gz

lightphe 0.0.8tar.gz → 0.0.9tar.gz