lightphe 0.0.9__tar.gz → 0.0.10__tar.gz

{lightphe-0.0.9 → lightphe-0.0.10}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: lightphe
-Version: 0.0.9
+Version: 0.0.10
 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/) ([`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/).
+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/), [`Koblitz`](sefiks.com/2016/03/13/the-math-behind-elliptic-curves-over-binary-field/) 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
 
@@ -245,6 +245,32 @@ 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.
 
+### Elliptic Curve Cryptography
+
+ECC is a powerful public-key cryptosystem based on the algebraic structure of elliptic curves over finite fields. In LightPHE, the [Elliptic Curve ElGamal](https://sefiks.com/2018/08/21/elliptic-curve-elgamal-encryption/) scheme is implemented, offering a secure and efficient homomorphic encryption option. The library supports 100+ standard elliptic curves.
+
+```python
+some_curves = [
+    {"form": "weierstrass", "curve": "secp256k1"},
+    {"form": "edwards", "curve": "ed25519"},
+    {"form": "koblitz", "curve": "k163"}
+]
+
+curve = some_curves[1]
+
+phe = LightPHE(
+    algorithm_name="EllipticCurve-ElGamal",
+    form=curve["form"],
+    curve=curve["curve"],
+)
+```
+
+One of the crucial factors that define the security level of an elliptic curve cryptosystem is the order of the curve. The order of a curve is the number of points on the curve, and it directly influences the strength of the encryption. A higher order typically corresponds to a stronger cryptosystem, making it more resistant to cryptographic attacks.
+
+Each curve in LightPHE has a specific order, which is carefully chosen to balance performance and security. By selecting an elliptic curve with a larger order, you increase the security of your cryptographic system, but this may come with a trade-off in computational efficiency. Therefore, choosing the appropriate curve order is a crucial decision based on your application’s security and performance requirements.
+
+See [`Curves`](https://github.com/serengil/LightPHE/tree/master/lightphe/elliptic_curve_forms) page for more details.
+
 # 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.9 → lightphe-0.0.10}/README.md

@@ -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/) ([`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/).
+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/), [`Koblitz`](sefiks.com/2016/03/13/the-math-behind-elliptic-curves-over-binary-field/) 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
 
@@ -229,6 +229,32 @@ 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.
 
+### Elliptic Curve Cryptography
+
+ECC is a powerful public-key cryptosystem based on the algebraic structure of elliptic curves over finite fields. In LightPHE, the [Elliptic Curve ElGamal](https://sefiks.com/2018/08/21/elliptic-curve-elgamal-encryption/) scheme is implemented, offering a secure and efficient homomorphic encryption option. The library supports 100+ standard elliptic curves.
+
+```python
+some_curves = [
+    {"form": "weierstrass", "curve": "secp256k1"},
+    {"form": "edwards", "curve": "ed25519"},
+    {"form": "koblitz", "curve": "k163"}
+]
+
+curve = some_curves[1]
+
+phe = LightPHE(
+    algorithm_name="EllipticCurve-ElGamal",
+    form=curve["form"],
+    curve=curve["curve"],
+)
+```
+
+One of the crucial factors that define the security level of an elliptic curve cryptosystem is the order of the curve. The order of a curve is the number of points on the curve, and it directly influences the strength of the encryption. A higher order typically corresponds to a stronger cryptosystem, making it more resistant to cryptographic attacks.
+
+Each curve in LightPHE has a specific order, which is carefully chosen to balance performance and security. By selecting an elliptic curve with a larger order, you increase the security of your cryptographic system, but this may come with a trade-off in computational efficiency. Therefore, choosing the appropriate curve order is a crucial decision based on your application’s security and performance requirements.
+
+See [`Curves`](https://github.com/serengil/LightPHE/tree/master/lightphe/elliptic_curve_forms) page for more details.
+
 # 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.9 → lightphe-0.0.10}/lightphe/__init__.py

@@ -23,7 +23,8 @@ logger = Logger(module="lightphe/__init__.py")
 
 
 class LightPHE:
-    __version__ = "0.0.9"
+    __version__ = "0.0.10"
+
     def __init__(
         self,
         algorithm_name: str,
@@ -31,7 +32,8 @@ class LightPHE:
         key_file: Optional[str] = None,
         key_size: Optional[int] = None,
         precision: int = 5,
-        form: str = "weierstrass",
+        form: Optional[str] = None,
+        curve: Optional[str] = None,
     ):
         """
         Build LightPHE class
@@ -43,19 +45,30 @@ 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'.
+            form (str): specifies the form of the elliptic curve.
+                Options: 'weierstrass' (default), 'edwards', 'koblitz'.
+                This parameter is only used if `algorithm_name` is 'EllipticCurve-ElGamal'.
+            curve (str): specifies the elliptic curve to use.
+                Options:
+                 - e.g. ed25519, ed448 for edwards form
+                 - e.g. secp256k1 for weierstrass form
+                 - e.g. k-409 for koblitz form
                 This parameter is only used if `algorithm_name` is 'EllipticCurve-ElGamal'.
         """
         self.algorithm_name = algorithm_name
         self.precision = precision
         self.form = form
+        self.curve = curve
 
         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, form=form,
+            algorithm_name=algorithm_name,
+            keys=keys,
+            key_size=key_size,
+            form=form,
+            curve=curve,
         )
 
     def __build_cryptosystem(
@@ -64,6 +77,7 @@ class LightPHE:
         keys: Optional[dict] = None,
         key_size: Optional[int] = None,
         form: Optional[str] = None,
+        curve: Optional[str] = None,
     ) -> Union[
         RSA,
         ElGamal,
@@ -83,9 +97,14 @@ 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
-            form (str): specifies the form of the elliptic curve. 
+            form (str): specifies the form of the elliptic curve.
                 Options: 'weierstrass' (default), 'edwards'.
                 This parameter is only used if `algorithm_name` is 'EllipticCurve-ElGamal'.
+            curve (str): specifies the elliptic curve to use.
+                Options:
+                 - ed25519, ed448 for edwards form
+                 - secp256k1 for weierstrass form
+                This parameter is only used if `algorithm_name` is 'EllipticCurve-ElGamal'.
         Returns
             cryptosystem
         """
@@ -97,7 +116,9 @@ 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, form=form)
+            cs = EllipticCurveElGamal(
+                keys=keys, key_size=key_size, form=form, curve=curve
+            )
         elif algorithm_name == Algorithm.Paillier:
             cs = Paillier(keys=keys, key_size=key_size)
         elif algorithm_name == Algorithm.DamgardJurik:
@@ -114,7 +135,9 @@ class LightPHE:
             raise ValueError(f"unimplemented algorithm - {algorithm_name}")
         return cs
 
-    def encrypt(self, plaintext: Union[int, float, list]) -> Union[Ciphertext, EncryptedTensor]:
+    def encrypt(
+        self, plaintext: Union[int, float, list]
+    ) -> Union[Ciphertext, EncryptedTensor]:
         """
         Encrypt a plaintext with a built cryptosystem
         Args:
@@ -130,9 +153,17 @@ class LightPHE:
             return self.__encrypt_tensors(tensor=plaintext)
 
         ciphertext = self.cs.encrypt(
-            plaintext=phe_utils.parse_int(value=plaintext, modulo=self.cs.plaintext_modulo)
+            plaintext=phe_utils.normalize_input(
+                value=plaintext, modulo=self.cs.plaintext_modulo
+            )
+        )
+        return Ciphertext(
+            algorithm_name=self.algorithm_name,
+            keys=self.cs.keys,
+            value=ciphertext,
+            form=self.form,
+            curve=self.curve,
         )
-        return Ciphertext(algorithm_name=self.algorithm_name, keys=self.cs.keys, value=ciphertext, form=self.form)
 
     def decrypt(
         self, ciphertext: Union[Ciphertext, EncryptedTensor]
@@ -171,7 +202,8 @@ class LightPHE:
                     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)
+                    plaintext=(abs(m) % self.cs.plaintext_modulo)
+                    * pow(10, self.precision)
                 )
                 divisor_encrypted = self.cs.encrypt(plaintext=pow(10, self.precision))
                 c = Fraction(
@@ -205,7 +237,9 @@ class LightPHE:
             encrypted_tensor.append(c)
         return EncryptedTensor(fractions=encrypted_tensor, cs=self.cs)
 
-    def __decrypt_tensors(self, encrypted_tensor: EncryptedTensor) -> Union[List[int], List[float]]:
+    def __decrypt_tensors(
+        self, encrypted_tensor: EncryptedTensor
+    ) -> Union[List[int], List[float]]:
         """
         Decrypt a given encrypted tensor
         Args:
@@ -304,4 +338,6 @@ class LightPHE:
         Returns:
             Ciphertext
         """
-        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
+        )

lightphe-0.0.10/lightphe/commons/binary_operations.py

@@ -0,0 +1,147 @@
+"""
+This module is heavily inspired by repo github.com/dimitrijray/ecc-binary-field/blob/master/binop.py
+"""
+
+
+def divide(a: int, b: int, p: int) -> int:
+    """
+    Returns a_bin * (b_bin)^-1 (mod p)
+    Args:
+        a (int): nominator
+        b (int): denominator
+        p (int): modulo
+    Returns:
+        result (int): (a_bin * (b_bin)^-1 (mod p)) mod p
+    """
+    result = mod(multi(a, inverse(b, p)), p)
+    return result
+
+
+def multi(a: int, b: int) -> int:
+    """
+    Multiply two binary numbers in GF(2).
+    Args:
+        a (int): first number
+        b (int): second number
+    Returns:
+        result (int): carry-less multiplication between a and b
+    """
+    result = 0
+    shift = 0
+
+    while b > 0:
+        if b & 1:  # Check if the least significant bit of b is 1
+            result ^= a << shift
+        shift += 1
+        b >>= 1  # Shift b to the right by 1
+
+    return result
+
+
+def power_mod(num: int, exp: int, modulo: int) -> int:
+    """
+    Calculate num^exp (mod m) in GF(2).
+    Args:
+        num (int): base
+        exp (int): exponent
+        modulo (int): modulo
+    Returns:
+        result (int): num^exp (mod m)
+    """
+    result = 1
+    base = num % modulo
+
+    while exp > 0:
+        if exp & 1:  # Check if the least significant bit of exp is 1
+            result = multi(base, result)  # multiply result by base
+            result = mod(result, modulo)  # apply modulo
+
+        base = square(base)  # square the base
+        exp >>= 1  # right shift exp by 1
+
+    return result
+
+
+def square(num: int) -> int:
+    """
+    Square a binary number in GF(2).
+    Args:
+        num (int): number
+    Returns:
+        result (int): square of num
+    """
+    result = 0
+    shift = 0
+
+    while num > 0:
+        if num & 1:  # Check if the least significant bit of num is 1
+            result ^= 1 << (2 * shift)  # Set the appropriate bit in the result
+
+        num >>= 1  # Right shift num by 1
+        shift += 1
+
+    return result
+
+
+def mod(num: int, modulo: int) -> int:
+    """
+    Perform modulo operation for binary numbers in GF(2).
+    Args:
+        num (int): number
+        modulo (int): modulo
+    Returns:
+        result (int): num mod modulo
+    """
+    degP = num.bit_length() - 1
+    degR = modulo.bit_length() - 1
+
+    while degP >= degR and degR != 0:
+        shift = degP - degR
+        num ^= modulo << shift  # Perform XOR to reduce the degree of num
+        degP = num.bit_length() - 1  # Update the degree of num
+
+    return num
+
+
+def div(num: int, modulo: int) -> int:
+    """
+    Return the quotient of the polynomial division num / modulo in GF(2).
+    Args:
+        num (int): numerator
+        modulo (int): denominator
+    Returns:
+        result (int): quotient
+    """
+    deg_p = num.bit_length() - 1
+    deg_r = modulo.bit_length() - 1
+    q = 0
+
+    while deg_p >= deg_r:
+        shift = deg_p - deg_r
+        q |= 1 << shift  # Set the corresponding bit in the quotient
+        num ^= modulo << shift  # Perform XOR to reduce the degree of num
+        deg_p = num.bit_length() - 1  # Update the degree of num
+
+    return q
+
+
+def inverse(num: int, modulo: int) -> int:
+    """
+    Calculate the inverse of a binary number modulo a polynomial in GF(2).
+    Args:
+        num (int): number
+        modulo (int): modulo
+    Returns:
+        result (int): inverse of num mod modulo
+    """
+    a, b = num, modulo
+    p1, p2 = 1, 0
+
+    while b != 1:
+        q = div(a, b)
+        r = mod(a, b)
+        a, b = b, r
+        p_a = p1 ^ multi(q, p2)
+        p1, p2 = p2, p_a
+
+    return p2

{lightphe-0.0.9 → lightphe-0.0.10}/lightphe/commons/phe_utils.py

@@ -1,5 +1,8 @@
+# built-in dependencies
 from typing import Union, Tuple, Optional
 from decimal import Decimal, getcontext
+
+# project dependencies
 from lightphe.commons.logger import Logger
 
 logger = Logger(module="lightphe/commons/phe_utils.py")
@@ -7,8 +10,19 @@ 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):
+def normalize_input(value: Union[int, float], modulo: Union[int, str]) -> int:
+    """
+    Normaliz given value to be in the range of modulo
+    Args:
+        value (int, float): the value to be normalized
+        modulo (int): the modulo value
+    Returns:
+        result (int, str): the normalized value
+    """
+    if isinstance(value, int) and isinstance(modulo, str):
+        # elliptic curve elgamal & koblitz curves
+        result = value % int(modulo, 2)
+    elif isinstance(value, int) and isinstance(modulo, int):
         result = value % modulo
     elif isinstance(value, float) and value >= 0:
         dividend, divisor = fractionize(value=value, modulo=modulo)
@@ -23,7 +37,9 @@ def parse_int(value: Union[int, float], modulo: int) -> int:
     return result
 
 
-def fractionize(value: float, modulo: int, precision: Optional[int] = None) -> Tuple[int, int]:
+def fractionize(
+    value: float, modulo: int, precision: Optional[int] = None
+) -> Tuple[int, int]:
     getcontext().prec = 50
 
     if precision is None:
@@ -40,7 +56,9 @@ def fractionize(value: float, modulo: int, precision: Optional[int] = None) -> T
 
         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)))
+            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

{lightphe-0.0.9 → lightphe-0.0.10}/lightphe/cryptosystems/EllipticCurveElGamal.py

@@ -3,6 +3,7 @@ from typing import Optional
 from lightphe.models.Homomorphic import Homomorphic
 from lightphe.elliptic_curve_forms.weierstrass import Weierstrass
 from lightphe.elliptic_curve_forms.edwards import TwistedEdwards
+from lightphe.elliptic_curve_forms.koblitz import Koblitz
 from lightphe.commons.logger import Logger
 
 logger = Logger(module="lightphe/cryptosystems/EllipticCurveElGamal.py")
@@ -17,7 +18,13 @@ class EllipticCurveElGamal(Homomorphic):
     Ref: https://sefiks.com/2018/08/21/elliptic-curve-elgamal-encryption/
     """
 
-    def __init__(self, keys: Optional[dict] = None, key_size: Optional[int] = None, form: str = "weierstrass"):
+    def __init__(
+        self,
+        keys: Optional[dict] = None,
+        key_size: Optional[int] = None,
+        form: Optional[str] = None,
+        curve: Optional[str] = None,
+    ):
         """
         Args:
             keys (dict): private - public key pair.
@@ -26,19 +33,26 @@ class EllipticCurveElGamal(Homomorphic):
                 this is equivalent to 1024 bit RSA.
             form (str): specifies the elliptic curve form.
                 Options are 'weierstrass' (default), 'edwards'.
+            curve (str): specifies the elliptic curve to use.
+                Options:
+                 - ed25519, ed448 for edwards form
+                 - secp256k1 for weierstrass form
+                This parameter is only used if `algorithm_name` is 'EllipticCurve-ElGamal'.
         """
         if form is None or form == "weierstrass":
-            self.curve = Weierstrass()
+            self.curve = Weierstrass(curve=curve)
         elif form in "edwards":
-            self.curve = TwistedEdwards()
+            self.curve = TwistedEdwards(curve=curve)
+        elif form in "koblitz":
+            self.curve = Koblitz(curve=curve)
         else:
             raise ValueError(f"unimplemented curve form - {form}")
 
-        self.keys = keys or self.generate_keys(key_size or 160)
+        self.keys = keys or self.generate_keys(key_size or self.curve.n.bit_length())
         self.keys["public_key"]["form"] = form
         self.keys["private_key"]["form"] = form
-        self.plaintext_modulo = self.curve.p
-        self.ciphertext_modulo = self.curve.p
+        self.plaintext_modulo = self.curve.modulo
+        self.ciphertext_modulo = self.curve.modulo
 
     def generate_keys(self, key_size: int):
         """
@@ -54,9 +68,12 @@ class EllipticCurveElGamal(Homomorphic):
 
         # private key
         ka = random.getrandbits(key_size)
+        logger.debug(
+            f"{key_size} bit private key generated for Elliptic Curve ElGamal."
+        )
 
         # public key
-        Qa = self.curve.double_and_add(G=self.curve.G, k=ka, p=self.curve.p)
+        Qa = self.curve.double_and_add(G=self.curve.G, k=ka)
 
         keys["public_key"]["Qa"] = Qa
         keys["private_key"]["ka"] = ka
@@ -69,7 +86,11 @@ class EllipticCurveElGamal(Homomorphic):
         Returns:
             random key (int): one time random key for encryption
         """
-        return random.getrandbits(128)
+        # return random.getrandbits(128)
+        return random.getrandbits(
+            (isinstance(self.curve.n, int) and self.curve.n.bit_length())
+            or (isinstance(self.curve.n, str) and len(self.curve.n))
+        )
 
     def encrypt(self, plaintext: int, random_key: Optional[int] = None) -> tuple:
         """
@@ -80,9 +101,6 @@ class EllipticCurveElGamal(Homomorphic):
         Returns
             ciphertext (tuple): c1 and c2
         """
-        # modulo
-        p = self.curve.p
-
         # base point
         G = self.curve.G
 
@@ -92,12 +110,12 @@ class EllipticCurveElGamal(Homomorphic):
         # random key
         r = random_key or self.generate_random_key()
 
-        s = self.curve.double_and_add(G=G, k=plaintext, p=p)
+        s = self.curve.double_and_add(G=G, k=plaintext)
 
-        c1 = self.curve.double_and_add(G=G, k=r, p=p)
+        c1 = self.curve.double_and_add(G=G, k=r)
 
-        c2 = self.curve.double_and_add(G=Qa, k=r, p=p)
-        c2 = self.curve.add_points(c2, s, p)
+        c2 = self.curve.double_and_add(G=Qa, k=r)
+        c2 = self.curve.add_points(c2, s)
 
         return c1, c2
 
@@ -109,17 +127,14 @@ class EllipticCurveElGamal(Homomorphic):
         Returns:
             plaintext (int): restored message
         """
-        # modulo
-        p = self.curve.p
-
         # private key
         ka = self.keys["private_key"]["ka"]
 
         c1, c2 = ciphertext
 
-        c1_prime = self.curve.negative_point(c1, p)
-        s_prime = self.curve.double_and_add(G=c1_prime, k=ka, p=p)
-        s_prime = self.curve.add_points(P=c2, Q=s_prime, p=p)
+        c1_prime = self.curve.negative_point(c1)
+        s_prime = self.curve.double_and_add(G=c1_prime, k=ka)
+        s_prime = self.curve.add_points(P=c2, Q=s_prime)
 
         # s_prime is a point on the elliptic curve
         # s_prime = k x G
@@ -130,12 +145,14 @@ class EllipticCurveElGamal(Homomorphic):
         G = self.curve.G
         k = 2
         while True:
-            G = self.curve.add_points(P=G, Q=self.curve.G, p=p)
+            G = self.curve.add_points(P=G, Q=self.curve.G)
             if G[0] == s_prime[0] and G[1] == s_prime[1]:
                 return k
             k = k + 1
             if k > self.curve.n:
-                raise ValueError(f"Cannot restore scalar from {s_prime} = k x {self.curve.G}")
+                raise ValueError(
+                    f"Cannot restore scalar from {s_prime} = k x {self.curve.G}"
+                )
 
     def multiply(self, ciphertext1: tuple, ciphertext2: tuple) -> tuple:
         raise ValueError(
@@ -152,8 +169,8 @@ class EllipticCurveElGamal(Homomorphic):
         Returns
             ciphertext (dict): Elliptic Curve ElGamal ciphertext consisting of c1 and c2 keys
         """
-        a = self.curve.add_points(P=ciphertext1[0], Q=ciphertext2[0], p=self.curve.p)
-        b = self.curve.add_points(P=ciphertext1[1], Q=ciphertext2[1], p=self.curve.p)
+        a = self.curve.add_points(P=ciphertext1[0], Q=ciphertext2[0])
+        b = self.curve.add_points(P=ciphertext1[1], Q=ciphertext2[1])
         return a, b
 
     def xor(self, ciphertext1: tuple, ciphertext2: tuple) -> int:
@@ -173,8 +190,11 @@ class EllipticCurveElGamal(Homomorphic):
             ciphertext (int): new ciphertext created with Elliptic Curve ElGamal
         """
         return self.curve.double_and_add(
-            G=ciphertext[0], k=constant, p=self.curve.p
-        ), self.curve.double_and_add(G=ciphertext[1], k=constant, p=self.curve.p)
+            G=ciphertext[0],
+            k=constant,
+        ), self.curve.double_and_add(G=ciphertext[1], k=constant)
 
     def reencrypt(self, ciphertext: tuple) -> tuple:
-        raise ValueError("Elliptic Curve ElGamal does not support regeneration of ciphertext")
+        raise ValueError(
+            "Elliptic Curve ElGamal does not support regeneration of ciphertext"
+        )