lightphe 0.0.22__tar.gz → 0.0.24__tar.gz

{lightphe-0.0.22 → lightphe-0.0.24}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: lightphe
-Version: 0.0.22
+Version: 0.0.24
 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/), [`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/), [`Sander-Young-Yung`](https://sefiks.com/2026/04/02/a-step-by-step-partially-homomorphic-sander-young-yung-example-in-python/), [`Boneh-Goh-Nissim`](https://sefiks.com/2026/04/02/a-step-by-step-somewhat-homomorphic-encryption-example-with-boneh-goh-nissim-in-python/).
+LightPHE is a lightweight homomorphic encryption library for python supporting various partially and somewhat homomorphic encryptions 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/), [`Sander-Young-Yung`](https://sefiks.com/2026/04/02/a-step-by-step-partially-homomorphic-sander-young-yung-example-in-python/), [`Boneh-Goh-Nissim`](https://sefiks.com/2026/04/02/a-step-by-step-somewhat-homomorphic-encryption-example-with-boneh-goh-nissim-in-python/).
 
 # Partially vs Fully Homomorphic Encryption
 
@@ -156,7 +156,7 @@ assert cs.decrypt(c3) == m1 * m2
 
 ### Ciphertext Regeneration
 
-The most of additively homomorphic algorithms allow 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.
+The most of homomorphic algorithms allow 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)

{lightphe-0.0.22 → lightphe-0.0.24}/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/), [`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/), [`Sander-Young-Yung`](https://sefiks.com/2026/04/02/a-step-by-step-partially-homomorphic-sander-young-yung-example-in-python/), [`Boneh-Goh-Nissim`](https://sefiks.com/2026/04/02/a-step-by-step-somewhat-homomorphic-encryption-example-with-boneh-goh-nissim-in-python/).
+LightPHE is a lightweight homomorphic encryption library for python supporting various partially and somewhat homomorphic encryptions 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/), [`Sander-Young-Yung`](https://sefiks.com/2026/04/02/a-step-by-step-partially-homomorphic-sander-young-yung-example-in-python/), [`Boneh-Goh-Nissim`](https://sefiks.com/2026/04/02/a-step-by-step-somewhat-homomorphic-encryption-example-with-boneh-goh-nissim-in-python/).
 
 # Partially vs Fully Homomorphic Encryption
 
@@ -140,7 +140,7 @@ assert cs.decrypt(c3) == m1 * m2
 
 ### Ciphertext Regeneration
 
-The most of additively homomorphic algorithms allow 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.
+The most of homomorphic algorithms allow 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)

{lightphe-0.0.22 → lightphe-0.0.24}/lightphe/__init__.py

@@ -16,6 +16,7 @@ from lightphe.models.Ciphertext import Ciphertext
 from lightphe.models.Algorithm import Algorithm
 from lightphe.models.Tensor import Fraction, EncryptedTensor
 from lightphe.commons import phe_utils
+from lightphe.commons.key_validator import validate_keys
 from lightphe.commons.logger import Logger
 
 # cryptosystems
@@ -36,7 +37,7 @@ from lightphe.cryptosystems.BonehGohNissim import BonehGohNissim
 
 logger = Logger(module="lightphe/__init__.py")
 
-VERSION = "0.0.22"
+VERSION = "0.0.24"
 
 
 class LightPHE:
@@ -90,6 +91,9 @@ class LightPHE:
         if key_file is not None:
             keys = self.restore_keys(target_file=key_file)
 
+        if keys is not None:
+            validate_keys(algorithm_name=algorithm_name, keys=keys)
+
         self.cs: Homomorphic = self.__build_cryptosystem(
             algorithm_name=algorithm_name,
             keys=keys,

lightphe-0.0.24/lightphe/commons/key_validator.py

@@ -0,0 +1,97 @@
+from typing import Dict, Type
+
+from lightphe.models.Algorithm import Algorithm
+from lightphe.models.Homomorphic import Homomorphic
+from lightphe.cryptosystems.RSA import RSA
+from lightphe.cryptosystems.ElGamal import ElGamal
+from lightphe.cryptosystems.EllipticCurveElGamal import EllipticCurveElGamal
+from lightphe.cryptosystems.Paillier import Paillier
+from lightphe.cryptosystems.DamgardJurik import DamgardJurik
+from lightphe.cryptosystems.OkamotoUchiyama import OkamotoUchiyama
+from lightphe.cryptosystems.Benaloh import Benaloh
+from lightphe.cryptosystems.NaccacheStern import NaccacheStern
+from lightphe.cryptosystems.GoldwasserMicali import GoldwasserMicali
+from lightphe.cryptosystems.SanderYoungYung import SanderYoungYung
+from lightphe.cryptosystems.BonehGohNissim import BonehGohNissim
+
+
+# Map user-facing algorithm names to the class that owns the REQUIRED_KEYS spec.
+# The spec itself lives as a class attribute on each cryptosystem.
+# Exponential-ElGamal reuses ElGamal's key structure.
+_ALGORITHM_TO_CLASS: Dict[str, Type[Homomorphic]] = {
+    Algorithm.RSA: RSA,
+    Algorithm.ElGamal: ElGamal,
+    Algorithm.ExponentialElGamal: ElGamal,
+    Algorithm.EllipticCurveElGamal: EllipticCurveElGamal,
+    Algorithm.Paillier: Paillier,
+    Algorithm.DamgardJurik: DamgardJurik,
+    Algorithm.OkamotoUchiyama: OkamotoUchiyama,
+    Algorithm.Benaloh: Benaloh,
+    Algorithm.NaccacheStern: NaccacheStern,
+    Algorithm.GoldwasserMicali: GoldwasserMicali,
+    Algorithm.SanderYoungYung: SanderYoungYung,
+    Algorithm.BonehGohNissim: BonehGohNissim,
+}
+
+
+def validate_keys(algorithm_name: str, keys: dict) -> None:
+    """
+    Validate that user-supplied keys carry the required sub-fields for the
+    given cryptosystem. `public_key` is always required (every cryptosystem
+    needs it for encryption); `private_key` is optional (absent in
+    encryption-only setups). Whichever is present must contain all its
+    required sub-fields.
+
+    The required-field spec is read from the cryptosystem class's
+    `REQUIRED_KEYS` attribute (a dict with "public_key", "private_key", and
+    an optional "nested" entry for dict-valued public_key sub-fields).
+
+    Args:
+        algorithm_name (str): user-facing algorithm name (e.g. "RSA")
+        keys (dict): user-supplied keys dict
+    Raises:
+        ValueError: when required fields are missing or structure is wrong
+    """
+    cls = _ALGORITHM_TO_CLASS.get(algorithm_name)
+    if cls is None:
+        return
+    spec = cls.REQUIRED_KEYS
+
+    if not isinstance(keys, dict):
+        raise ValueError(
+            f"{algorithm_name} keys must be a dict, got {type(keys).__name__}"
+        )
+
+    if "public_key" not in keys:
+        raise ValueError(f"{algorithm_name} keys must contain 'public_key'")
+
+    for kind in ("public_key", "private_key"):
+        if kind not in keys:
+            continue
+        if not isinstance(keys[kind], dict):
+            raise ValueError(
+                f"{algorithm_name} '{kind}' must be a dict, "
+                f"got {type(keys[kind]).__name__}"
+            )
+        missing = [f for f in spec[kind] if f not in keys[kind]]
+        if missing:
+            raise ValueError(
+                f"{algorithm_name} '{kind}' is missing required fields: {missing}"
+            )
+
+    nested = spec.get("nested") or {}
+    for parent, required in nested.items():
+        if "public_key" not in keys or parent not in keys["public_key"]:
+            continue
+        sub = keys["public_key"][parent]
+        if not isinstance(sub, dict):
+            raise ValueError(
+                f"{algorithm_name} 'public_key.{parent}' must be a dict, "
+                f"got {type(sub).__name__}"
+            )
+        missing = [f for f in required if f not in sub]
+        if missing:
+            raise ValueError(
+                f"{algorithm_name} 'public_key.{parent}' is missing required "
+                f"fields: {missing}"
+            )

{lightphe-0.0.22 → lightphe-0.0.24}/lightphe/cryptosystems/Benaloh.py

@@ -15,6 +15,11 @@ logger = Logger(module="lightphe/cryptosystems/Benaloh.py")
 
 
 class Benaloh(Homomorphic):
+    REQUIRED_KEYS = {
+        "public_key": ["y", "r", "n"],
+        "private_key": ["p", "q", "phi", "x"],
+    }
+
     def __init__(
         self,
         keys: Optional[dict] = None,

{lightphe-0.0.22 → lightphe-0.0.24}/lightphe/cryptosystems/BonehGohNissim.py

@@ -5,6 +5,7 @@ from typing import Optional, Tuple, Union
 
 # third-party dependencies
 from lightecc import LightECC
+from lightecc.commons.errors import InvalidCurveOrder, PointNotOnCurve
 from lightecc.interfaces.elliptic_curve import EllipticCurvePoint
 from lightecc.commons.pairing import _fp2_pow, _fp2_mul
 import sympy
@@ -25,6 +26,12 @@ class BonehGohNissim(Homomorphic):
     Ref: https://sefiks.com/2026/04/02/a-step-by-step-somewhat-homomorphic-encryption-example-with-boneh-goh-nissim-in-python/
     """
 
+    REQUIRED_KEYS = {
+        "public_key": ["curve", "G", "u", "h", "l"],
+        "private_key": ["q1", "q2"],
+        "nested": {"curve": ["a", "b", "p", "G", "n"]},
+    }
+
     def __init__(
         self,
         keys: Optional[dict] = None,
@@ -54,7 +61,10 @@ class BonehGohNissim(Homomorphic):
             },
         )
 
-        self.plaintext_modulo = self.ec.modulo
+        if "private_key" in self.keys and "q2" in self.keys["private_key"]:
+            self.plaintext_modulo = self.keys["private_key"]["q2"]
+        else:
+            self.plaintext_modulo = self.keys["public_key"]["curve"]["n"]
         self.ciphertext_modulo = self.ec.modulo
 
     def generate_keys(
@@ -103,22 +113,21 @@ class BonehGohNissim(Homomorphic):
 
             G = self.__find_generator(p, max_tries=max_tries)
 
-            # order of the curve may not be exactly n, but it should be
-            self.ec = LightECC(
-                form_name="weierstrass",
-                curve_name="custom",
-                config={"a": a, "b": b, "p": p, "G": G, "n": None},
-            )
-
-            nG = n * self.ec.G
-            if (
-                nG == self.ec.O
-            ):  # check if nG is the point at infinity / identity element / neutral element
-                logger.debug("nG is the point at infinity, as expected.")
-                logger.debug(f"q1 = {q1}, q2 = {q2}, n = {n}, p = {p}, l = {l}")
-                break
+            try:
+                self.ec = LightECC(
+                    form_name="weierstrass",
+                    curve_name="custom",
+                    config={"a": a, "b": b, "p": p, "G": G, "n": n},
+                )
+            except (InvalidCurveOrder, PointNotOnCurve):
+                logger.debug(
+                    f"Curve order validation failed for attempt {key_attempt + 1}, retrying"
+                )
+                continue
 
-            logger.debug(f"nG not infinity, retrying (attempt {key_attempt + 1})")
+            logger.debug("Curve order validated by LightECC.")
+            logger.debug(f"q1 = {q1}, q2 = {q2}, n = {n}, p = {p}, l = {l}")
+            break
         else:
             raise Exception(f"Failed to generate keys after {max_tries} attempts")
 
@@ -160,14 +169,28 @@ class BonehGohNissim(Homomorphic):
 
         raise Exception(f"Failed to find a generator after {max_tries} attempts")
 
+    def _has_private_key(self) -> bool:
+        return "private_key" in self.keys and "q2" in self.keys["private_key"]
+
     def generate_random_key(self) -> int:
         """
         Boneh-Goh-Nissim requires to generate one-time random key per encryption
         Returns:
             random key (int): one time random key for encryption
         """
-        q2 = self.keys["private_key"]["q2"]
-        return random.randint(1, q2 - 1)
+        if self._has_private_key():
+            q2 = self.keys["private_key"]["q2"]
+            return random.randint(1, q2 - 1)
+
+        n = self.keys["public_key"]["curve"]["n"]
+        logger.warn(
+            "Private key is not available. Random key will be bounded by n"
+            " instead of q2. Encryption will work for small plaintexts,"
+            " but negative number encoding via plaintext_modulo will not"
+            " round-trip correctly because plaintext_modulo is set to n"
+            " (public) instead of q2 (private)."
+        )
+        return random.randint(1, n - 1)
 
     def encrypt(
         self, plaintext: int, random_key: Optional[int] = None
@@ -200,23 +223,28 @@ class BonehGohNissim(Homomorphic):
             plaintext (int): restored message
         """
         q1 = self.keys["private_key"]["q1"]
+        q2 = self.keys["private_key"]["q2"]
 
         if isinstance(ciphertext, tuple):
-            return self._decrypt_gt(ciphertext, q1)
+            return self._decrypt_gt(ciphertext, q1, q2)
 
         G = self.ec.G
 
         mP = ciphertext * q1
         P = G * q1
 
-        for i in range(1, q1 + 1):
+        # P has order q2, so DLP result is in [0, q2)
+        if mP == self.ec.O:
+            return 0
+
+        for i in range(1, q2):
             iP = P * i
             if iP == mP:
                 return i
 
         raise Exception("Decryption failed")
 
-    def _decrypt_gt(self, ciphertext: tuple, q1: int) -> int:
+    def _decrypt_gt(self, ciphertext: tuple, q1: int, q2: int) -> int:
         """
         Decrypt a G_T ciphertext (result of homomorphic multiplication).
 
@@ -241,9 +269,12 @@ class BonehGohNissim(Homomorphic):
         base = _fp2_pow(e_gg, q1, p)
         target = _fp2_pow(ciphertext, q1, p)
 
-        # brute-force DLP in G_T
+        # brute-force DLP in G_T — result is in [0, q2)
+        if target == (1, 0):
+            return 0
+
         acc = (1, 0)
-        for i in range(1, q1 + 1):
+        for i in range(1, q2):
             acc = _fp2_mul(acc, base, p)
             if acc == target:
                 return i

{lightphe-0.0.22 → lightphe-0.0.24}/lightphe/cryptosystems/DamgardJurik.py

@@ -15,6 +15,11 @@ class DamgardJurik(Homomorphic):
     Ref: https://sefiks.com/2023/10/20/a-step-by-step-partially-homomorphic-encryption-example-with-damgard-jurik-in-python/
     """
 
+    REQUIRED_KEYS = {
+        "public_key": ["g", "n", "s"],
+        "private_key": ["phi"],
+    }
+
     def __init__(self, s: int = 2, keys: Optional[dict] = None, key_size: Optional[int] = None):
         """
         Args:

{lightphe-0.0.22 → lightphe-0.0.24}/lightphe/cryptosystems/ElGamal.py

@@ -19,6 +19,11 @@ class ElGamal(Homomorphic):
     Ref: https://sefiks.com/2023/03/27/a-step-by-step-partially-homomorphic-encryption-example-with-elgamal-in-python/
     """
 
+    REQUIRED_KEYS = {
+        "public_key": ["p", "g", "y"],
+        "private_key": ["x"],
+    }
+
     def __init__(self, keys: Optional[dict] = None, exponential=False, key_size: Optional[int] = None):
         """
         Args:

{lightphe-0.0.22 → lightphe-0.0.24}/lightphe/cryptosystems/EllipticCurveElGamal.py

@@ -22,6 +22,11 @@ class EllipticCurveElGamal(Homomorphic):
     Ref: https://sefiks.com/2018/08/21/elliptic-curve-elgamal-encryption/
     """
 
+    REQUIRED_KEYS = {
+        "public_key": ["Qa"],
+        "private_key": ["ka"],
+    }
+
     def __init__(
         self,
         keys: Optional[dict] = None,

{lightphe-0.0.22 → lightphe-0.0.24}/lightphe/cryptosystems/GoldwasserMicali.py

@@ -23,6 +23,11 @@ class GoldwasserMicali(Homomorphic):
     Ref: sefiks.com/2023/10/27/a-step-by-step-partially-homomorphic-encryption-example-with-goldwasser-micali-in-python/
     """
 
+    REQUIRED_KEYS = {
+        "public_key": ["n", "x"],
+        "private_key": ["p", "q"],
+    }
+
     def __init__(
         self,
         keys: Optional[dict] = None,

{lightphe-0.0.22 → lightphe-0.0.24}/lightphe/cryptosystems/NaccacheStern.py

@@ -20,6 +20,11 @@ class NaccacheStern(Homomorphic):
     Original paper: https://dl.acm.org/doi/pdf/10.1145/288090.288106
     """
 
+    REQUIRED_KEYS = {
+        "public_key": ["n", "g", "sigma"],
+        "private_key": ["a", "b", "p", "q", "phi", "prime_set"],
+    }
+
     def __init__(
         self,
         keys: Optional[dict] = None,

{lightphe-0.0.22 → lightphe-0.0.24}/lightphe/cryptosystems/OkamotoUchiyama.py

@@ -14,6 +14,11 @@ class OkamotoUchiyama(Homomorphic):
     Ref: https://sefiks.com/2023/10/20/a-step-by-step-partially-homomorphic-encryption-example-with-okamoto-uchiyama-in-python/
     """
 
+    REQUIRED_KEYS = {
+        "public_key": ["n", "g", "h"],
+        "private_key": ["p", "q"],
+    }
+
     def __init__(self, keys: Optional[dict] = None, key_size: Optional[int] = None):
         """
         Args:

{lightphe-0.0.22 → lightphe-0.0.24}/lightphe/cryptosystems/Paillier.py

@@ -15,6 +15,11 @@ class Paillier(Homomorphic):
     Ref: https://sefiks.com/2023/04/03/a-step-by-step-partially-homomorphic-encryption-example-with-paillier-in-python/
     """
 
+    REQUIRED_KEYS = {
+        "public_key": ["g", "n"],
+        "private_key": ["phi"],
+    }
+
     def __init__(self, keys: Optional[dict] = None, key_size: Optional[int] = None):
         """
         Args:

{lightphe-0.0.22 → lightphe-0.0.24}/lightphe/cryptosystems/RSA.py

@@ -14,6 +14,11 @@ class RSA(Homomorphic):
     Ref: https://sefiks.com/2023/03/06/a-step-by-step-partially-homomorphic-encryption-example-with-rsa-in-python/
     """
 
+    REQUIRED_KEYS = {
+        "public_key": ["n", "e"],
+        "private_key": ["d"],
+    }
+
     def __init__(
         self,
         keys: Optional[dict] = None,

{lightphe-0.0.22 → lightphe-0.0.24}/lightphe/cryptosystems/SanderYoungYung.py

@@ -21,6 +21,11 @@ class SanderYoungYung(Homomorphic):
         Ref: https://sefiks.com/2026/04/02/a-step-by-step-partially-homomorphic-sander-young-yung-example-in-python/
     """
 
+    REQUIRED_KEYS = {
+        "public_key": ["n", "x", "l"],
+        "private_key": ["p", "q"],
+    }
+
     def __init__(
         self,
         keys: Optional[dict] = None,

{lightphe-0.0.22 → lightphe-0.0.24}/lightphe/models/Homomorphic.py

@@ -17,6 +17,13 @@ class Homomorphic(ABC):
     plaintext_modulo: int
     ciphertext_modulo: int
 
+    # Cryptosystems must define REQUIRED_KEYS as a dict with:
+    #   - "public_key":  list of required sub-fields in keys["public_key"]
+    #   - "private_key": list of required sub-fields in keys["private_key"]
+    #   - "nested" (optional): dict mapping a public_key sub-field that itself
+    #       holds a dict to its required sub-fields.
+    REQUIRED_KEYS: dict
+
     @abstractmethod
     def generate_keys(
         self,

{lightphe-0.0.22 → lightphe-0.0.24}/lightphe.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: lightphe
-Version: 0.0.22
+Version: 0.0.24
 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/), [`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/), [`Sander-Young-Yung`](https://sefiks.com/2026/04/02/a-step-by-step-partially-homomorphic-sander-young-yung-example-in-python/), [`Boneh-Goh-Nissim`](https://sefiks.com/2026/04/02/a-step-by-step-somewhat-homomorphic-encryption-example-with-boneh-goh-nissim-in-python/).
+LightPHE is a lightweight homomorphic encryption library for python supporting various partially and somewhat homomorphic encryptions 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/), [`Sander-Young-Yung`](https://sefiks.com/2026/04/02/a-step-by-step-partially-homomorphic-sander-young-yung-example-in-python/), [`Boneh-Goh-Nissim`](https://sefiks.com/2026/04/02/a-step-by-step-somewhat-homomorphic-encryption-example-with-boneh-goh-nissim-in-python/).
 
 # Partially vs Fully Homomorphic Encryption
 
@@ -156,7 +156,7 @@ assert cs.decrypt(c3) == m1 * m2
 
 ### Ciphertext Regeneration
 
-The most of additively homomorphic algorithms allow 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.
+The most of homomorphic algorithms allow 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)

{lightphe-0.0.22 → lightphe-0.0.24}/lightphe.egg-info/SOURCES.txt

@@ -9,6 +9,7 @@ lightphe.egg-info/dependency_links.txt
 lightphe.egg-info/requires.txt
 lightphe.egg-info/top_level.txt
 lightphe/commons/__init__.py
+lightphe/commons/key_validator.py
 lightphe/commons/logger.py
 lightphe/commons/phe_utils.py
 lightphe/cryptosystems/Benaloh.py
@@ -38,6 +39,7 @@ tests/test_elgamal.py
 tests/test_ellipticcurveelgamal.py
 tests/test_exporting_keys.py
 tests/test_goldwasser.py
+tests/test_key_validator.py
 tests/test_keys.py
 tests/test_large_keys.py
 tests/test_naccache.py

{lightphe-0.0.22 → lightphe-0.0.24}/lightphe.egg-info/requires.txt

@@ -1,3 +1,3 @@
 sympy>=1.12
 tqdm
-lightecc>=0.0.5
+lightecc>=0.0.6

{lightphe-0.0.22 → lightphe-0.0.24}/requirements.txt

@@ -1,3 +1,3 @@
 sympy>=1.12
 tqdm
-lightecc>=0.0.5
+lightecc>=0.0.6

{lightphe-0.0.22 → lightphe-0.0.24}/setup.py

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

{lightphe-0.0.22 → lightphe-0.0.24}/tests/test_bonehgohnissim.py

@@ -108,6 +108,77 @@ def test_linear_regression():
     )
 
 
+def test_cosine_similarity():
+    tic = time.time()
+    i1 = 5
+    i2 = 2
+    i3 = 8
+
+    # v2 = [1, 1, 2]
+    j1 = 1
+    j2 = 1
+    j3 = 2
+
+    i1_enc = cs.encrypt(i1)
+    i2_enc = cs.encrypt(i2)
+    i3_enc = cs.encrypt(i3)
+
+    j1_enc = cs.encrypt(j1)
+    j2_enc = cs.encrypt(j2)
+    j3_enc = cs.encrypt(j3)
+
+    # homomorphic operation
+    cosine_sim_enc = i1_enc * j1_enc + i2_enc * j2_enc + i3_enc * j3_enc
+
+    # proof of work
+    assert cs.decrypt(cosine_sim_enc) == i1 * j1 + i2 * j2 + i3 * j3
+
+    logger.info(
+        f"✅ Boneh-God-Nissim cosine similarity test succeeded "
+        f"({security_level} bit ECC security level)"
+        f" in {time.time() - tic:.2f} seconds"
+    )
+
+
+def test_euclidean_distance():
+    tic = time.time()
+
+    # v1 = [5, 2, 3]
+    i1 = 5
+    i2 = 2
+    i3 = 8
+
+    # v2 = [1, 1, 2]
+    j1 = 1
+    j2 = 1
+    j3 = 2
+
+    i1_enc = cs.encrypt(i1)
+    i2_enc = cs.encrypt(i2)
+    i3_enc = cs.encrypt(i3)
+
+    j1_enc = cs.encrypt(-j1)
+    j2_enc = cs.encrypt(-j2)
+    j3_enc = cs.encrypt(-j3)
+
+    euclidean_sqrt_enc = (
+        (i1_enc + j1_enc) * (i1_enc + j1_enc)
+        + (i2_enc + j2_enc) * (i2_enc + j2_enc)
+        + (i3_enc + j3_enc) * (i3_enc + j3_enc)
+    )
+
+    assert (
+        cs.decrypt(euclidean_sqrt_enc)
+        == (i1 - j1) ** 2 + (i2 - j2) ** 2 + (i3 - j3) ** 2
+    )
+
+    logger.info(
+        f"✅ Boneh-God-Nissim euclidean distance test succeeded "
+        f"({security_level} bit ECC security level)"
+        f" in {time.time() - tic:.2f} seconds"
+    )
+
+
 def test_api_with_predefined_keys():
     keys = {
         "private_key": {"q1": 1260048562698661, "q2": 1495813357973021},

lightphe-0.0.24/tests/test_key_validator.py

@@ -0,0 +1,100 @@
+import copy
+
+import pytest
+
+from lightphe import LightPHE
+from lightphe.commons.logger import Logger
+
+logger = Logger(module="tests/test_key_validator.py")
+
+
+ALGORITHMS = [
+    ("RSA", 50),
+    ("ElGamal", 50),
+    ("Exponential-ElGamal", 50),
+    ("EllipticCurve-ElGamal", 50),
+    ("Paillier", 50),
+    ("Damgard-Jurik", 50),
+    ("Okamoto-Uchiyama", 50),
+    ("Benaloh", 50),
+    ("Naccache-Stern", 50),
+    ("Goldwasser-Micali", 50),
+    ("Sander-Young-Yung", 50),
+    ("Boneh-Goh-Nissim", 50),
+]
+
+
+@pytest.mark.parametrize("algorithm_name,key_size", ALGORITHMS)
+def test_missing_public_key_field_is_rejected(algorithm_name, key_size):
+    """Dropping a required public_key sub-field must raise ValueError."""
+    cs = LightPHE(algorithm_name=algorithm_name, key_size=key_size, max_tries=10000)
+    field = cs.cs.REQUIRED_KEYS["public_key"][0]
+
+    broken = copy.deepcopy(cs.cs.keys)
+    del broken["public_key"][field]
+
+    with pytest.raises(ValueError, match=f"missing required fields.*{field}"):
+        LightPHE(algorithm_name=algorithm_name, keys=broken)
+
+    logger.info(f"✅ {algorithm_name}: missing public_key.{field} rejected")
+
+
+@pytest.mark.parametrize("algorithm_name,key_size", ALGORITHMS)
+def test_missing_private_key_field_is_rejected(algorithm_name, key_size):
+    """Dropping a required private_key sub-field must raise ValueError."""
+    cs = LightPHE(algorithm_name=algorithm_name, key_size=key_size, max_tries=10000)
+    field = cs.cs.REQUIRED_KEYS["private_key"][0]
+
+    broken = copy.deepcopy(cs.cs.keys)
+    del broken["private_key"][field]
+
+    with pytest.raises(ValueError, match=f"missing required fields.*{field}"):
+        LightPHE(algorithm_name=algorithm_name, keys=broken)
+
+    logger.info(f"✅ {algorithm_name}: missing private_key.{field} rejected")
+
+
+def test_missing_public_key_dict_is_rejected():
+    """A keys dict without public_key must be rejected."""
+    with pytest.raises(ValueError, match="must contain 'public_key'"):
+        LightPHE(algorithm_name="RSA", keys={})
+
+
+def test_private_key_only_is_rejected():
+    """Supplying private_key without public_key must be rejected."""
+    cs = LightPHE(algorithm_name="RSA", key_size=50)
+    private_only = {"private_key": copy.deepcopy(cs.cs.keys["private_key"])}
+    with pytest.raises(ValueError, match="must contain 'public_key'"):
+        LightPHE(algorithm_name="RSA", keys=private_only)
+
+
+def test_non_dict_keys_is_rejected():
+    """A non-dict `keys` argument must be rejected."""
+    with pytest.raises(ValueError, match="keys must be a dict"):
+        LightPHE(algorithm_name="RSA", keys="not-a-dict")
+
+
+def test_public_key_only_is_accepted():
+    """Supplying only a full public_key must be accepted (encryption-only use)."""
+    cs = LightPHE(algorithm_name="RSA", key_size=50)
+    public_only = {"public_key": copy.deepcopy(cs.cs.keys["public_key"])}
+    # should not raise
+    LightPHE(algorithm_name="RSA", keys=public_only)
+
+
+def test_bgn_nested_curve_field_is_rejected():
+    """Dropping a required BGN curve sub-field must be rejected."""
+    cs = LightPHE(algorithm_name="Boneh-Goh-Nissim", key_size=50, max_tries=10000)
+    nested = cs.cs.REQUIRED_KEYS.get("nested", {}).get("curve", [])
+    assert nested, "BGN must declare nested curve required fields"
+    field = nested[0]
+
+    broken = copy.deepcopy(cs.cs.keys)
+    del broken["public_key"]["curve"][field]
+
+    with pytest.raises(
+        ValueError, match=rf"public_key\.curve.*missing required fields.*{field}"
+    ):
+        LightPHE(algorithm_name="Boneh-Goh-Nissim", keys=broken)
+
+    logger.info(f"✅ BGN: missing public_key.curve.{field} rejected")