lightphe 0.0.9__tar.gz → 0.0.11__tar.gz

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: lightphe
-Version: 0.0.9
+Version: 0.0.11
 Summary: A Lightweight Partially Homomorphic Encryption Library for Python
 Home-page: https://github.com/serengil/LightPHE
 Author: Sefik Ilkin Serengil
@@ -22,7 +22,8 @@ License-File: LICENSE
 [![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)
-[![DOI](http://img.shields.io/:DOI-10.48550/arXiv.2408.05219-blue.svg?style=flat)](https://arxiv.org/abs/2408.05219)
+[![arXiv](https://img.shields.io/badge/arXiv-2408.05219-b31b1b.svg?logo=arXiv)](https://arxiv.org/abs/2408.05219)
+<!-- [![DOI](http://img.shields.io/:DOI-10.48550/arXiv.2408.05219-blue.svg?style=flat)](https://arxiv.org/abs/2408.05219) -->
 
 [![Blog](https://img.shields.io/:blog-sefiks.com-blue.svg?style=flat&logo=wordpress)](https://sefiks.com)
 [![YouTube](https://img.shields.io/:youtube-@sefiks-red.svg?style=flat&logo=youtube)](https://www.youtube.com/@sefiks?sub_confirmation=1)
@@ -36,7 +37,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 +246,48 @@ 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. The library supports 3 elliptic curve forms (weierstrass, edwards and koblitz) and 100+ standard elliptic curve configurations.
+
+Building an elliptic curve with LightPHE is very straightforward. Once the curve is initialized, you can perform operations such as point addition and scalar multiplication.
+
+```python
+from lightphe import ECC
+
+forms = ["weierstrass", "edwards", "koblitz"]
+
+# construct an elliptic curve
+ed = ECC(form_name="edwards")
+
+# Base Point
+G = ed.G
+
+_2G = G + G
+_3G = _2G + G
+_5G = _3G + _2G
+
+_20G = 4 * G
+_19G = _20G - G
+```
+
+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.
+
+```python
+forms = ["weierstass", "edwards", "koblitz"]
+
+phe = LightPHE(
+    algorithm_name="EllipticCurve-ElGamal",
+    form=forms[1],
+)
+```
+
+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 a list of all supported forms, curves and their 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.11}/README.md

@@ -6,7 +6,8 @@
 [![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)
-[![DOI](http://img.shields.io/:DOI-10.48550/arXiv.2408.05219-blue.svg?style=flat)](https://arxiv.org/abs/2408.05219)
+[![arXiv](https://img.shields.io/badge/arXiv-2408.05219-b31b1b.svg?logo=arXiv)](https://arxiv.org/abs/2408.05219)
+<!-- [![DOI](http://img.shields.io/:DOI-10.48550/arXiv.2408.05219-blue.svg?style=flat)](https://arxiv.org/abs/2408.05219) -->
 
 [![Blog](https://img.shields.io/:blog-sefiks.com-blue.svg?style=flat&logo=wordpress)](https://sefiks.com)
 [![YouTube](https://img.shields.io/:youtube-@sefiks-red.svg?style=flat&logo=youtube)](https://www.youtube.com/@sefiks?sub_confirmation=1)
@@ -20,7 +21,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 +230,48 @@ 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. The library supports 3 elliptic curve forms (weierstrass, edwards and koblitz) and 100+ standard elliptic curve configurations.
+
+Building an elliptic curve with LightPHE is very straightforward. Once the curve is initialized, you can perform operations such as point addition and scalar multiplication.
+
+```python
+from lightphe import ECC
+
+forms = ["weierstrass", "edwards", "koblitz"]
+
+# construct an elliptic curve
+ed = ECC(form_name="edwards")
+
+# Base Point
+G = ed.G
+
+_2G = G + G
+_3G = _2G + G
+_5G = _3G + _2G
+
+_20G = 4 * G
+_19G = _20G - G
+```
+
+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.
+
+```python
+forms = ["weierstass", "edwards", "koblitz"]
+
+phe = LightPHE(
+    algorithm_name="EllipticCurve-ElGamal",
+    form=forms[1],
+)
+```
+
+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 a list of all supported forms, curves and their 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.11}/lightphe/__init__.py

@@ -1,10 +1,17 @@
+# built-in dependencies
 import json
 from typing import Optional, Union, List
 
+# project dependencies
 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.models.EllipticCurve import EllipticCurvePoint
+from lightphe.commons import phe_utils
+from lightphe.commons.logger import Logger
+
+# cryptosystems
 from lightphe.cryptosystems.RSA import RSA
 from lightphe.cryptosystems.ElGamal import ElGamal
 from lightphe.cryptosystems.Paillier import Paillier
@@ -14,16 +21,21 @@ 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 phe_utils
-from lightphe.commons.logger import Logger
+from lightphe.elliptic_curve_forms.weierstrass import Weierstrass
+from lightphe.elliptic_curve_forms.edwards import TwistedEdwards
+from lightphe.elliptic_curve_forms.koblitz import Koblitz
+
 
-# pylint: disable=eval-used, simplifiable-if-expression
+# pylint: disable=eval-used, simplifiable-if-expression, too-few-public-methods
 
 logger = Logger(module="lightphe/__init__.py")
 
+VERSION = "0.0.11"
+
 
 class LightPHE:
-    __version__ = "0.0.9"
+    __version__ = VERSION
+
     def __init__(
         self,
         algorithm_name: str,
@@ -31,7 +43,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 +56,32 @@ 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
+                List of all available curves:
+                    github.com/serengil/LightPHE/blob/master/lightphe/elliptic_curve_forms/README.md
                 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 +90,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 +110,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 +129,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 +148,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 +166,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 +215,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 +250,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 +351,47 @@ 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
+        )
+
+
+class ECC:
+    __version__ = VERSION
+
+    def __init__(
+        self, form_name: Optional[str] = None, curve_name: Optional[str] = None
+    ):
+        """
+        Construct an Elliptic Curve over a finite field (prime or binary)
+        Args:
+            form_name (str): specifies the form of the elliptic curve.
+                Options: 'weierstrass' (default), 'edwards', 'koblitz'.
+            curve_name (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
+                List of all available curves:
+                    github.com/serengil/LightPHE/blob/master/lightphe/elliptic_curve_forms/README.md
+        """
+        if form_name is None or form_name == "weierstrass":
+            self.curve = Weierstrass(curve=curve_name)
+        elif form_name in "edwards":
+            self.curve = TwistedEdwards(curve=curve_name)
+        elif form_name in "koblitz":
+            self.curve = Koblitz(curve=curve_name)
+        else:
+            raise ValueError(f"unimplemented curve form - {form_name}")
+
+        # base point
+        self.G = EllipticCurvePoint(self.curve.G[0], self.curve.G[1], self.curve)
+
+        # order of the curve
+        self.n = self.curve.n
+
+        # point at infinity or neutral / identity element
+        self.O = EllipticCurvePoint(self.curve.O[0], self.curve.O[1], self.curve)
+
+        # modulo
+        self.modulo = self.curve.modulo

lightphe-0.0.11/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.11}/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