lightphe 0.0.23__tar.gz → 0.0.25__tar.gz

{lightphe-0.0.23 → lightphe-0.0.25}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: lightphe
-Version: 0.0.23
+Version: 0.0.25
 Summary: A Lightweight Partially Homomorphic Encryption Library for Python
 Home-page: https://github.com/serengil/LightPHE
 Author: Sefik Ilkin Serengil
@@ -65,7 +65,7 @@ from lightphe import LightPHE
 
 # Summary of Homomorphic Features of Different Cryptosystems in LightPHE
 
-In summary, LightPHE is covering following algorithms and these are partially homomorphic with respect to the operations mentioned in the following table.
+In summary, LightPHE is covering following algorithms and these are partially homomorphic and somewhat homomorphic with respect to the operations mentioned in the following table.
 
 | Algorithm | Multiplicatively<br>Homomorphic | Additively<br>Homomorphic | Scalar Multiplication | Bitwise-XOR Homomorphic | Bitwise-AND Homomorphic | Regeneration<br>of Ciphertext |
 | --- | --- | --- | --- | --- | --- | --- |
@@ -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)
@@ -248,22 +248,17 @@ Also, your company's logo will be shown on README on GitHub if you become sponso
 Please cite LightPHE in your publications if it helps your research. Here is its BibTex entry:
 
 ```BibTeX
-@article{serengil2024lightphe,
-  title={LightPHE: Integrating Partially Homomorphic Encryption into Python with Extensive Cloud Environment Evaluations},
-  author={Serengil, Sefik Ilkin and Ozpinar, Alper},
-  journal={arXiv preprint arXiv:2408.05219},
-  note={doi: 10.48550/arXiv.2408.05219. [Online]. Available: \url{https://arxiv.org/abs/2408.05219}},
-  year={2025}
-}
-```
-
-```BibTeX
-@article{serengil2025vectorsimilarity,
-  title={Encrypted Vector Similarity Computations Using Partially Homomorphic Encryption: Applications and Performance Analysis},
-  author={Serengil, Sefik and Ozpinar, Alper},
-  journal={arXiv preprint arXiv:2503.05850},
-  note={doi: 10.48550/arXiv.2503.05850. [Online]. Available: \url{https://arxiv.org/abs/2503.05850}},
-  year={2025}
+@article{sym18050832,
+  title          = {Sustainable Cryptography: Carbon Asymmetry in Partially Homomorphic Encryption in the Cloud},
+  author         = {Ozpinar, Alper and Serengil, Sefik Ilkin},
+  journal        = {Symmetry},
+  volume         = {18},
+  number         = {5},
+  pages          = {832},
+  url            = {https://www.mdpi.com/2073-8994/18/5/832},
+  doi            = {10.3390/sym18050832},
+  note           = {Special Issue: Symmetry in Cryptography and Cybersecurity},
+  year           = {2026}
 }
 ```
 

{lightphe-0.0.23 → lightphe-0.0.25}/README.md

@@ -49,7 +49,7 @@ from lightphe import LightPHE
 
 # Summary of Homomorphic Features of Different Cryptosystems in LightPHE
 
-In summary, LightPHE is covering following algorithms and these are partially homomorphic with respect to the operations mentioned in the following table.
+In summary, LightPHE is covering following algorithms and these are partially homomorphic and somewhat homomorphic with respect to the operations mentioned in the following table.
 
 | Algorithm | Multiplicatively<br>Homomorphic | Additively<br>Homomorphic | Scalar Multiplication | Bitwise-XOR Homomorphic | Bitwise-AND Homomorphic | Regeneration<br>of Ciphertext |
 | --- | --- | --- | --- | --- | --- | --- |
@@ -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)
@@ -232,22 +232,17 @@ Also, your company's logo will be shown on README on GitHub if you become sponso
 Please cite LightPHE in your publications if it helps your research. Here is its BibTex entry:
 
 ```BibTeX
-@article{serengil2024lightphe,
-  title={LightPHE: Integrating Partially Homomorphic Encryption into Python with Extensive Cloud Environment Evaluations},
-  author={Serengil, Sefik Ilkin and Ozpinar, Alper},
-  journal={arXiv preprint arXiv:2408.05219},
-  note={doi: 10.48550/arXiv.2408.05219. [Online]. Available: \url{https://arxiv.org/abs/2408.05219}},
-  year={2025}
-}
-```
-
-```BibTeX
-@article{serengil2025vectorsimilarity,
-  title={Encrypted Vector Similarity Computations Using Partially Homomorphic Encryption: Applications and Performance Analysis},
-  author={Serengil, Sefik and Ozpinar, Alper},
-  journal={arXiv preprint arXiv:2503.05850},
-  note={doi: 10.48550/arXiv.2503.05850. [Online]. Available: \url{https://arxiv.org/abs/2503.05850}},
-  year={2025}
+@article{sym18050832,
+  title          = {Sustainable Cryptography: Carbon Asymmetry in Partially Homomorphic Encryption in the Cloud},
+  author         = {Ozpinar, Alper and Serengil, Sefik Ilkin},
+  journal        = {Symmetry},
+  volume         = {18},
+  number         = {5},
+  pages          = {832},
+  url            = {https://www.mdpi.com/2073-8994/18/5/832},
+  doi            = {10.3390/sym18050832},
+  note           = {Special Issue: Symmetry in Cryptography and Cybersecurity},
+  year           = {2026}
 }
 ```
 

{lightphe-0.0.23 → lightphe-0.0.25}/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
@@ -31,12 +32,11 @@ from lightphe.cryptosystems.EllipticCurveElGamal import EllipticCurveElGamal
 from lightphe.cryptosystems.SanderYoungYung import SanderYoungYung
 from lightphe.cryptosystems.BonehGohNissim import BonehGohNissim
 
-
 # pylint: disable=eval-used, simplifiable-if-expression, too-few-public-methods
 
 logger = Logger(module="lightphe/__init__.py")
 
-VERSION = "0.0.23"
+VERSION = "0.0.25"
 
 
 class LightPHE:
@@ -90,6 +90,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.25/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.23 → lightphe-0.0.25}/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.23 → lightphe-0.0.25}/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,
@@ -106,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")
 

{lightphe-0.0.23 → lightphe-0.0.25}/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.23 → lightphe-0.0.25}/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.23 → lightphe-0.0.25}/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.23 → lightphe-0.0.25}/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.23 → lightphe-0.0.25}/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"],
+    }
+
     def __init__(
         self,
         keys: Optional[dict] = None,
@@ -54,10 +59,11 @@ class NaccacheStern(Homomorphic):
         Returns:
             keys (dict): containing 'private_key' and 'public_key'
         """
-        # Small prime set (the largest one is 10-bits)
-        # Using a smaller prime_set to make key generation feasible for large key sizes
-        # prime_set = [3, 5, 7, 11, 13, 17]
-        prime_set = [3, 5, 7, 11]
+        # Small primes are required so DLP remains solvable during decryption.
+        # Picking 4 out of these 8 keeps sigma small (<= ~23^4) and splits
+        # evenly into u and v.
+        small_primes = [3, 5, 7, 11, 13, 17, 19, 23]
+        prime_set = sorted(random.sample(small_primes, 4))
         k = len(prime_set)
 
         if all(sympy.isprime(prime) is True for prime in prime_set) is False:
@@ -167,7 +173,6 @@ class NaccacheStern(Homomorphic):
                     "p": p,
                     "q": q,
                     "phi": phi,
-                    "prime_set": prime_set,
                 },
             }
             logger.debug(
@@ -227,7 +232,9 @@ class NaccacheStern(Homomorphic):
         phi = self.keys["private_key"]["phi"]
         n = self.keys["public_key"]["n"]
         g = self.keys["public_key"]["g"]
-        prime_set = self.keys["private_key"]["prime_set"]
+        sigma = self.keys["public_key"]["sigma"]
+        # sigma is the product of the small primes; recover them by factoring.
+        prime_set = sorted(sympy.factorint(sigma).keys())
 
         remainders = []
         for i, prime in enumerate(prime_set):

{lightphe-0.0.23 → lightphe-0.0.25}/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.23 → lightphe-0.0.25}/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.23 → lightphe-0.0.25}/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.23 → lightphe-0.0.25}/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.23 → lightphe-0.0.25}/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.23 → lightphe-0.0.25}/lightphe.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: lightphe
-Version: 0.0.23
+Version: 0.0.25
 Summary: A Lightweight Partially Homomorphic Encryption Library for Python
 Home-page: https://github.com/serengil/LightPHE
 Author: Sefik Ilkin Serengil
@@ -65,7 +65,7 @@ from lightphe import LightPHE
 
 # Summary of Homomorphic Features of Different Cryptosystems in LightPHE
 
-In summary, LightPHE is covering following algorithms and these are partially homomorphic with respect to the operations mentioned in the following table.
+In summary, LightPHE is covering following algorithms and these are partially homomorphic and somewhat homomorphic with respect to the operations mentioned in the following table.
 
 | Algorithm | Multiplicatively<br>Homomorphic | Additively<br>Homomorphic | Scalar Multiplication | Bitwise-XOR Homomorphic | Bitwise-AND Homomorphic | Regeneration<br>of Ciphertext |
 | --- | --- | --- | --- | --- | --- | --- |
@@ -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)
@@ -248,22 +248,17 @@ Also, your company's logo will be shown on README on GitHub if you become sponso
 Please cite LightPHE in your publications if it helps your research. Here is its BibTex entry:
 
 ```BibTeX
-@article{serengil2024lightphe,
-  title={LightPHE: Integrating Partially Homomorphic Encryption into Python with Extensive Cloud Environment Evaluations},
-  author={Serengil, Sefik Ilkin and Ozpinar, Alper},
-  journal={arXiv preprint arXiv:2408.05219},
-  note={doi: 10.48550/arXiv.2408.05219. [Online]. Available: \url{https://arxiv.org/abs/2408.05219}},
-  year={2025}
-}
-```
-
-```BibTeX
-@article{serengil2025vectorsimilarity,
-  title={Encrypted Vector Similarity Computations Using Partially Homomorphic Encryption: Applications and Performance Analysis},
-  author={Serengil, Sefik and Ozpinar, Alper},
-  journal={arXiv preprint arXiv:2503.05850},
-  note={doi: 10.48550/arXiv.2503.05850. [Online]. Available: \url{https://arxiv.org/abs/2503.05850}},
-  year={2025}
+@article{sym18050832,
+  title          = {Sustainable Cryptography: Carbon Asymmetry in Partially Homomorphic Encryption in the Cloud},
+  author         = {Ozpinar, Alper and Serengil, Sefik Ilkin},
+  journal        = {Symmetry},
+  volume         = {18},
+  number         = {5},
+  pages          = {832},
+  url            = {https://www.mdpi.com/2073-8994/18/5/832},
+  doi            = {10.3390/sym18050832},
+  note           = {Special Issue: Symmetry in Cryptography and Cybersecurity},
+  year           = {2026}
 }
 ```
 

{lightphe-0.0.23 → lightphe-0.0.25}/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.23 → lightphe-0.0.25}/lightphe.egg-info/requires.txt

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

{lightphe-0.0.23 → lightphe-0.0.25}/requirements.txt

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

{lightphe-0.0.23 → lightphe-0.0.25}/setup.py

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

lightphe-0.0.25/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")

{lightphe-0.0.23 → lightphe-0.0.25}/tests/test_naccache.py

@@ -23,7 +23,6 @@ def test_predefined_keys():
             "p": 2435378721695886057509882054966317293278393717736720131443144187793510457493213363945300094351007614623267282257550830261688773235268185768920658432760349591,
             "q": 30909025587173888031151320439694649143770740813345918276468695473548278783448460260839705132326515527669756851362284434022860932531472563869828240743607816519,
             "phi": 75275183223356977395233015128636801841182684353869611205877871399639096259927846711964449336873721703958210179653876541687516247046310691985977881277598653806134265954388527744361895141375770783671899073915178636812972605279037227887538978553609742276161772286758627935090233305041395360684118422229078186256527620,
-            "prime_set": [3, 5, 7, 11, 13, 17],
         },
     }
 
@@ -33,7 +32,7 @@ def test_predefined_keys():
 
     security_level = cs.cs.keys["public_key"]["n"].bit_length()
 
-    logger.info(
+    logger.debug(
         f"Naccache-Stern cs built with {security_level} bits key. Recommended >= 768."
     )
 
@@ -44,13 +43,13 @@ def test_predefined_keys():
     c1 = cs.encrypt(plaintext=m1)
     c2 = cs.encrypt(plaintext=m2)
     toc = time.time()
-    logger.info(f"Naccache-Stern encryption time: {(toc - tic)/2:.4f} seconds")
+    logger.debug(f"Naccache-Stern encryption time: {(toc - tic)/2:.4f} seconds")
 
     # homomorphic addition
     tic = time.time()
     assert cs.decrypt(c1 + c2) == m1 + m2
     toc = time.time()
-    logger.info(f"Naccache-Stern homomorphic addition time: {(toc - tic):.4f} seconds")
+    logger.debug(f"Naccache-Stern homomorphic addition time: {(toc - tic):.4f} seconds")
 
     # homomorphic scalar multiplication
     tic = time.time()
@@ -59,7 +58,7 @@ def test_predefined_keys():
     m2_times_c1 = m2 * c1
     m1_times_c2 = m1 * c2
     toc = time.time()
-    logger.info(
+    logger.debug(
         f"Naccache-Stern homomorphic scalar multiplication time: {(toc - tic)/4:.4f} seconds"
     )