puantum 1.2.3__cp312-cp312-manylinux_2_34_x86_64.whl

puantum/__init__.py

@@ -0,0 +1 @@
+# EMPTY

puantum/classic/__init__.py

@@ -0,0 +1,2 @@
+# MAIN
+raise NotImplementedError()

puantum/quantum/__init__.py

@@ -0,0 +1 @@
+# EMPTY

puantum/quantum/dsa/__init__.py

@@ -0,0 +1,5 @@
+# IMPORT
+from puantum.quantum.dsa.__internal__ import Algorithm, KeyPair
+
+# MAIN
+__all__: list[str] = ["Algorithm", "KeyPair"]

puantum/quantum/dsa/__internal__.py

@@ -0,0 +1,550 @@
+# IMPORT
+from puantum import __internal__ as _internal # type: ignore
+import typing as _typing
+import enum as _enum
+
+# MAIN
+class Algorithm:
+    class CROSS(_enum.Enum):
+        CROSSR128B = "CrossRsdp128Balanced"
+        CROSSR128F = "CrossRsdp128Fast"
+        CROSSR128S = "CrossRsdp128Small"
+        CROSSR192B = "CrossRsdp192Balanced"
+        CROSSR192F = "CrossRsdp192Fast"
+        CROSSR192S = "CrossRsdp192Small"
+        CROSSR256B = "CrossRsdp256Balanced"
+        CROSSR256F = "CrossRsdp256Fast"
+        CROSSR256S = "CrossRsdp256Small"
+        CROSSRG128B = "CrossRsdpg128Balanced"
+        CROSSRG128F = "CrossRsdpg128Fast"
+        CROSSRG128S = "CrossRsdpg128Small"
+        CROSSRG192B = "CrossRsdpg192Balanced"
+        CROSSRG192F = "CrossRsdpg192Fast"
+        CROSSRG192S = "CrossRsdpg192Small"
+        CROSSRG256B = "CrossRsdpg256Balanced"
+        CROSSRG256F = "CrossRsdpg256Fast"
+        CROSSRG256S = "CrossRsdpg256Small"
+    #
+    class DILITHIUM(_enum.Enum):
+        DILITHIUM2 = "Dilithium2"
+        DILITHIUM3 = "Dilithium3"
+        DILITHIUM5 = "Dilithium5"
+    #
+    class FALCON(_enum.Enum):
+        FALCON512 = "Falcon512"
+        FALCON1024 = "Falcon1024"
+    #
+    class MAYO(_enum.Enum):
+        MAYO1 = "Mayo1"
+        MAYO2 = "Mayo2"
+        MAYO3 = "Mayo3"
+        MAYO5 = "Mayo5"
+    #
+    class MLDSA(_enum.Enum):
+        MLDSA44 = "MlDsa44"
+        MLDSA65 = "MlDsa65"
+        MLDSA87 = "MlDsa87"
+    #
+    class SPHINCS(_enum.Enum):
+        SHA2128F = "SphincsSha2128fSimple"
+        SHA2128S = "SphincsSha2128sSimple"
+        SHA2192F = "SphincsSha2192fSimple"
+        SHA2192S = "SphincsSha2192sSimple"
+        SHA2256F = "SphincsSha2256fSimple"
+        SHA2256S = "SphincsSha2256sSimple"
+        SHAKE128F = "SphincsShake128fSimple"
+        SHAKE128S = "SphincsShake128sSimple"
+        SHAKE192F = "SphincsShake192fSimple"
+        SHAKE192S = "SphincsShake192sSimple"
+        SHAKE256F = "SphincsShake256fSimple"
+        SHAKE256S = "SphincsShake256sSimple"
+    #
+    class UOV(_enum.Enum):
+        UOVOVIII = "UovOvIII"
+        UOVOVIIIPKC = "UovOvIIIPkc"
+        UOVOVIIIPKCSKC = "UovOvIIIPkcSkc"
+        UOVOVIP = "UovOvIp"
+        UOVOVIPPKC = "UovOvIpPkc"
+        UOVOVIPPKCSKC = "UovOvIpPkcSkc"
+        UOVOVIS = "UovOvIs"
+        UOVOVISPKC = "UovOvIsPkc"
+        UOVOVISPKCSKC = "UovOvIsPkcSkc"
+        UOVOVV = "UovOvV"
+        UOVOVVPKC = "UovOvVPkc"
+        UOVOVVPKCSKC = "UovOvVPkcSkc"
+
+
+
+class PublicKey:
+    def __init__(self, publickey: bytes) -> None:
+        if not isinstance(publickey, bytes):
+            raise TypeError("PublicKey Not Valid")
+        #
+        self.publickey = publickey
+        #
+        return None
+    #
+    def verify(self, signature: _typing.Any, message: _typing.Any) -> _typing.Any:
+        raise NotImplementedError()
+
+
+
+class CROSSPublicKey(PublicKey):
+    def __init__(self, name: Algorithm.CROSS, publickey: bytes) -> None:
+        if not isinstance(name, Algorithm.CROSS):
+            raise ValueError(f"Unsupported algorithm: {name}")
+        else:
+            super().__init__(publickey)
+        #
+        self._algorithm = name
+        #
+        return None
+    #
+    def verify(self, signature: bytes, message: bytes) -> bool:
+        result: bool = _internal.sigverify(self._algorithm.value, self.publickey, signature, message) # type: ignore
+        return result # type: ignore
+
+
+
+class DILITHIUMPublicKey(PublicKey):
+    def __init__(self, name: Algorithm.DILITHIUM, publickey: bytes) -> None:
+        if not isinstance(name, Algorithm.DILITHIUM):
+            raise ValueError(f"Unsupported algorithm: {name}")
+        else:
+            super().__init__(publickey)
+        #
+        self._algorithm = name
+        #
+        return None
+    #
+    def verify(self, signature: bytes, message: bytes) -> bool:
+        result: bool = _internal.sigverify(self._algorithm.value, self.publickey, signature, message) # type: ignore
+        return result # type: ignore
+
+
+
+class FALCONPublicKey(PublicKey):
+    def __init__(self, name: Algorithm.FALCON, publickey: bytes) -> None:
+        if not isinstance(name, Algorithm.FALCON):
+            raise ValueError(f"Unsupported algorithm: {name}")
+        else:
+            super().__init__(publickey)
+        #
+        self._algorithm = name
+        #
+        return None
+    #
+    def verify(self, signature: bytes, message: bytes) -> bool:
+        result: bool = _internal.sigverify(self._algorithm.value, self.publickey, signature, message) # type: ignore
+        return result # type: ignore
+
+
+
+class MAYOPublicKey(PublicKey):
+    def __init__(self, name: Algorithm.MAYO, publickey: bytes) -> None:
+        if not isinstance(name, Algorithm.MAYO):
+            raise ValueError(f"Unsupported algorithm: {name}")
+        else:
+            super().__init__(publickey)
+        #
+        self._algorithm = name
+        #
+        return None
+    #
+    def verify(self, signature: bytes, message: bytes) -> bool:
+        result: bool = _internal.sigverify(self._algorithm.value, self.publickey, signature, message) # type: ignore
+        return result # type: ignore
+
+
+
+class MLDSAPublicKey(PublicKey):
+    def __init__(self, name: Algorithm.MLDSA, publickey: bytes) -> None:
+        if not isinstance(name, Algorithm.MLDSA):
+            raise ValueError(f"Unsupported algorithm: {name}")
+        else:
+            super().__init__(publickey)
+        #
+        self._algorithm = name
+        #
+        return None
+    #
+    def verify(self, signature: bytes, message: bytes) -> bool:
+        result: bool = _internal.sigverify(self._algorithm.value, self.publickey, signature, message) # type: ignore
+        return result # type: ignore
+
+
+
+class SPHINCSPublicKey(PublicKey):
+    def __init__(self, name: Algorithm.SPHINCS, publickey: bytes) -> None:
+        if not isinstance(name, Algorithm.SPHINCS):
+            raise ValueError(f"Unsupported algorithm: {name}")
+        else:
+            super().__init__(publickey)
+        #
+        self._algorithm = name
+        #
+        return None
+    #
+    def verify(self, signature: bytes, message: bytes) -> bool:
+        result: bool = _internal.sigverify(self._algorithm.value, self.publickey, signature, message) # type: ignore
+        return result # type: ignore
+
+
+
+class UOVPublicKey(PublicKey):
+    def __init__(self, name: Algorithm.UOV, publickey: bytes) -> None:
+        if not isinstance(name, Algorithm.UOV):
+            raise ValueError(f"Unsupported algorithm: {name}")
+        else:
+            super().__init__(publickey)
+        #
+        self._algorithm = name
+        #
+        return None
+    #
+    def verify(self, signature: bytes, message: bytes) -> bool:
+        result: bool = _internal.sigverify(self._algorithm.value, self.publickey, signature, message) # type: ignore
+        return result # type: ignore
+
+
+
+class SecretKey:
+    def __init__(self, secretkey: bytes) -> None:
+        if not isinstance(secretkey, bytes):
+            raise TypeError("SecretKey Not Valid")
+        #
+        self.secretkey = secretkey
+        #
+        return None
+    #
+    def sign(self, message: _typing.Any) -> _typing.Any:
+        raise NotImplementedError()
+
+
+
+class CROSSSecretKey(SecretKey):
+    def __init__(self, name: Algorithm.CROSS, secretkey: bytes) -> None:
+        if not isinstance(name, Algorithm.CROSS):
+            raise ValueError(f"Unsupported algorithm: {name}")
+        else:
+            super().__init__(secretkey)
+        #
+        self._algorithm = name
+        #
+        return None
+    #
+    def sign(self, message: bytes) -> bytes:
+        signature: bytes = _internal.sigsign(self._algorithm.value, self.secretkey, message) # type: ignore
+        return signature # type: ignore
+
+
+
+class DILITHIUMSecretKey(SecretKey):
+    def __init__(self, name: Algorithm.DILITHIUM, secretkey: bytes) -> None:
+        if not isinstance(name, Algorithm.DILITHIUM):
+            raise ValueError(f"Unsupported algorithm: {name}")
+        else:
+            super().__init__(secretkey)
+        #
+        self._algorithm = name
+        #
+        return None
+    #
+    def sign(self, message: bytes) -> bytes:
+        signature: bytes = _internal.sigsign(self._algorithm.value, self.secretkey, message) # type: ignore
+        return signature # type: ignore
+
+
+
+class FALCONSecretKey(SecretKey):
+    def __init__(self, name: Algorithm.FALCON, secretkey: bytes) -> None:
+        if not isinstance(name, Algorithm.FALCON):
+            raise ValueError(f"Unsupported algorithm: {name}")
+        else:
+            super().__init__(secretkey)
+        #
+        self._algorithm = name
+        #
+        return None
+    #
+    def sign(self, message: bytes) -> bytes:
+        signature: bytes = _internal.sigsign(self._algorithm.value, self.secretkey, message) # type: ignore
+        return signature # type: ignore
+
+
+
+class MAYOSecretKey(SecretKey):
+    def __init__(self, name: Algorithm.MAYO, secretkey: bytes) -> None:
+        if not isinstance(name, Algorithm.MAYO):
+            raise ValueError(f"Unsupported algorithm: {name}")
+        else:
+            super().__init__(secretkey)
+        #
+        self._algorithm = name
+        #
+        return None
+    #
+    def sign(self, message: bytes) -> bytes:
+        signature: bytes = _internal.sigsign(self._algorithm.value, self.secretkey, message) # type: ignore
+        return signature # type: ignore
+
+
+
+class MLDSASecretKey(SecretKey):
+    def __init__(self, name: Algorithm.MLDSA, secretkey: bytes) -> None:
+        if not isinstance(name, Algorithm.MLDSA):
+            raise ValueError(f"Unsupported algorithm: {name}")
+        else:
+            super().__init__(secretkey)
+        #
+        self._algorithm = name
+        #
+        return None
+    #
+    def sign(self, message: bytes) -> bytes:
+        signature: bytes = _internal.sigsign(self._algorithm.value, self.secretkey, message) # type: ignore
+        return signature # type: ignore
+
+
+
+class SPHINCSSecretKey(SecretKey):
+    def __init__(self, name: Algorithm.SPHINCS, secretkey: bytes) -> None:
+        if not isinstance(name, Algorithm.SPHINCS):
+            raise ValueError(f"Unsupported algorithm: {name}")
+        else:
+            super().__init__(secretkey)
+        #
+        self._algorithm = name
+        #
+        return None
+    #
+    def sign(self, message: bytes) -> bytes:
+        signature: bytes = _internal.sigsign(self._algorithm.value, self.secretkey, message) # type: ignore
+        return signature # type: ignore
+
+
+
+class UOVSecretKey(SecretKey):
+    def __init__(self, name: Algorithm.UOV, secretkey: bytes) -> None:
+        if not isinstance(name, Algorithm.UOV):
+            raise ValueError(f"Unsupported algorithm: {name}")
+        else:
+            super().__init__(secretkey)
+        #
+        self._algorithm = name
+        #
+        return None
+    #
+    def sign(self, message: bytes) -> bytes:
+        signature: bytes = _internal.sigsign(self._algorithm.value, self.secretkey, message) # type: ignore
+        return signature # type: ignore
+
+
+
+@_typing.overload
+def KeyPair(
+    name: Algorithm,
+    *,
+    secretkey: bytes, publickey: bytes
+) -> tuple[SecretKey, PublicKey]: ...
+@_typing.overload
+def KeyPair(name: Algorithm, *, secretkey: bytes) -> SecretKey: ...
+@_typing.overload
+def KeyPair(name: Algorithm, *, publickey: bytes) -> PublicKey: ...
+@_typing.overload
+def KeyPair(name: Algorithm) -> tuple[SecretKey, PublicKey]: ...
+
+
+
+@_typing.overload
+def KeyPair(
+    name: Algorithm.CROSS,
+    *,
+    secretkey: bytes,
+    publickey: bytes
+) -> tuple[CROSSSecretKey, CROSSPublicKey]: ...
+@_typing.overload
+def KeyPair(name: Algorithm.CROSS, *, secretkey: bytes) -> CROSSSecretKey: ...
+@_typing.overload
+def KeyPair(name: Algorithm.CROSS, *, publickey: bytes) -> CROSSPublicKey: ...
+@_typing.overload
+def KeyPair(name: Algorithm.CROSS) -> tuple[CROSSSecretKey, CROSSPublicKey]: ...
+
+
+
+@_typing.overload
+def KeyPair(
+    name: Algorithm.DILITHIUM,
+    *,
+    secretkey: bytes,
+    publickey: bytes
+) -> tuple[DILITHIUMSecretKey, DILITHIUMPublicKey]: ...
+@_typing.overload
+def KeyPair(name: Algorithm.DILITHIUM, *, secretkey: bytes) -> DILITHIUMSecretKey: ...
+@_typing.overload
+def KeyPair(name: Algorithm.DILITHIUM, *, publickey: bytes) -> DILITHIUMPublicKey: ...
+@_typing.overload
+def KeyPair(name: Algorithm.DILITHIUM) -> tuple[DILITHIUMSecretKey, DILITHIUMPublicKey]: ...
+
+
+
+@_typing.overload
+def KeyPair(
+    name: Algorithm.FALCON,
+    *,
+    secretkey: bytes,
+    publickey: bytes
+) -> tuple[FALCONSecretKey, FALCONPublicKey]: ...
+@_typing.overload
+def KeyPair(name: Algorithm.FALCON, *, secretkey: bytes) -> FALCONSecretKey: ...
+@_typing.overload
+def KeyPair(name: Algorithm.FALCON, *, publickey: bytes) -> FALCONPublicKey: ...
+@_typing.overload
+def KeyPair(name: Algorithm.FALCON) -> tuple[FALCONSecretKey, FALCONPublicKey]: ...
+
+
+
+@_typing.overload
+def KeyPair(
+    name: Algorithm.MAYO,
+    *,
+    secretkey: bytes,
+    publickey: bytes
+) -> tuple[MAYOSecretKey, MAYOPublicKey]: ...
+@_typing.overload
+def KeyPair(name: Algorithm.MAYO, *, secretkey: bytes) -> MAYOSecretKey: ...
+@_typing.overload
+def KeyPair(name: Algorithm.MAYO, *, publickey: bytes) -> MAYOPublicKey: ...
+@_typing.overload
+def KeyPair(name: Algorithm.MAYO) -> tuple[MAYOSecretKey, MAYOPublicKey]: ...
+
+
+
+@_typing.overload
+def KeyPair(
+    name: Algorithm.MLDSA,
+    *,
+    secretkey: bytes,
+    publickey: bytes
+) -> tuple[MLDSASecretKey, MLDSAPublicKey]: ...
+@_typing.overload
+def KeyPair(name: Algorithm.MLDSA, *, secretkey: bytes) -> MLDSASecretKey: ...
+@_typing.overload
+def KeyPair(name: Algorithm.MLDSA, *, publickey: bytes) -> MLDSAPublicKey: ...
+@_typing.overload
+def KeyPair(name: Algorithm.MLDSA) -> tuple[MLDSASecretKey, MLDSAPublicKey]: ...
+
+
+
+@_typing.overload
+def KeyPair(
+    name: Algorithm.SPHINCS,
+    *,
+    secretkey: bytes,
+    publickey: bytes
+) -> tuple[SPHINCSSecretKey, SPHINCSPublicKey]: ...
+@_typing.overload
+def KeyPair(name: Algorithm.SPHINCS, *, secretkey: bytes) -> SPHINCSSecretKey: ...
+@_typing.overload
+def KeyPair(name: Algorithm.SPHINCS, *, publickey: bytes) -> SPHINCSPublicKey: ...
+@_typing.overload
+def KeyPair(name: Algorithm.SPHINCS) -> tuple[SPHINCSSecretKey, SPHINCSPublicKey]: ...
+
+
+
+@_typing.overload
+def KeyPair(
+    name: Algorithm.UOV,
+    *,
+    secretkey: bytes,
+    publickey: bytes
+) -> tuple[UOVSecretKey, UOVPublicKey]: ...
+@_typing.overload
+def KeyPair(name: Algorithm.UOV, *, secretkey: bytes) -> UOVSecretKey: ...
+@_typing.overload
+def KeyPair(name: Algorithm.UOV, *, publickey: bytes) -> UOVPublicKey: ...
+@_typing.overload
+def KeyPair(name: Algorithm.UOV) -> tuple[UOVSecretKey, UOVPublicKey]: ...
+
+
+
+Algorithms = Algorithm.CROSS | Algorithm.DILITHIUM | Algorithm.FALCON | Algorithm.MAYO | Algorithm.MLDSA | Algorithm.SPHINCS | Algorithm.UOV
+def KeyPair(
+        name: Algorithm | Algorithms,
+        *,
+        secretkey: bytes | None = None,
+        publickey: bytes | None = None
+    ) -> tuple[SecretKey, PublicKey] | SecretKey | PublicKey:
+    algorithm = name
+    if isinstance(algorithm, Algorithm.CROSS):
+        if secretkey is not None and publickey is None:
+            return CROSSSecretKey(algorithm, secretkey)
+        elif publickey is not None and secretkey is None:
+            return CROSSPublicKey(algorithm, publickey)
+        elif secretkey is not None and publickey is not None:
+            return CROSSSecretKey(algorithm, secretkey), CROSSPublicKey(algorithm, publickey)
+        else:
+            secretkey, publickey = _internal.sigkeygen(algorithm.value) # type: ignore
+            return CROSSSecretKey(algorithm, secretkey), CROSSPublicKey(algorithm, publickey) # type: ignore
+    elif isinstance(algorithm, Algorithm.DILITHIUM):
+        if secretkey is not None and publickey is None:
+            return DILITHIUMSecretKey(algorithm, secretkey)
+        elif publickey is not None and secretkey is None:
+            return DILITHIUMPublicKey(algorithm, publickey)
+        elif secretkey is not None and publickey is not None:
+            return DILITHIUMSecretKey(algorithm, secretkey), DILITHIUMPublicKey(algorithm, publickey)
+        else:
+            secretkey, publickey = _internal.sigkeygen(algorithm.value) # type: ignore
+            return DILITHIUMSecretKey(algorithm, secretkey), DILITHIUMPublicKey(algorithm, publickey) # type: ignore
+    elif isinstance(algorithm, Algorithm.FALCON):
+        if secretkey is not None and publickey is None:
+            return FALCONSecretKey(algorithm, secretkey)
+        elif publickey is not None and secretkey is None:
+            return FALCONPublicKey(algorithm, publickey)
+        elif secretkey is not None and publickey is not None:
+            return FALCONSecretKey(algorithm, secretkey), FALCONPublicKey(algorithm, publickey)
+        else:
+            secretkey, publickey = _internal.sigkeygen(algorithm.value) # type: ignore
+            return FALCONSecretKey(algorithm, secretkey), FALCONPublicKey(algorithm, publickey) # type: ignore
+    elif isinstance(algorithm, Algorithm.MAYO):
+        if secretkey is not None and publickey is None:
+            return MAYOSecretKey(algorithm, secretkey)
+        elif publickey is not None and secretkey is None:
+            return MAYOPublicKey(algorithm, publickey)
+        elif secretkey is not None and publickey is not None:
+            return MAYOSecretKey(algorithm, secretkey), MAYOPublicKey(algorithm, publickey)
+        else:
+            secretkey, publickey = _internal.sigkeygen(algorithm.value) # type: ignore
+            return MAYOSecretKey(algorithm, secretkey), MAYOPublicKey(algorithm, publickey) # type: ignore
+    elif isinstance(algorithm, Algorithm.MLDSA):
+        if secretkey is not None and publickey is None:
+            return MLDSASecretKey(algorithm, secretkey)
+        elif publickey is not None and secretkey is None:
+            return MLDSAPublicKey(algorithm, publickey)
+        elif secretkey is not None and publickey is not None:
+            return MLDSASecretKey(algorithm, secretkey), MLDSAPublicKey(algorithm, publickey)
+        else:
+            secretkey, publickey = _internal.sigkeygen(algorithm.value) # type: ignore
+            return MLDSASecretKey(algorithm, secretkey), MLDSAPublicKey(algorithm, publickey) # type: ignore
+    elif isinstance(algorithm, Algorithm.SPHINCS):
+        if secretkey is not None and publickey is None:
+            return SPHINCSSecretKey(algorithm, secretkey)
+        elif publickey is not None and secretkey is None:
+            return SPHINCSPublicKey(algorithm, publickey)
+        elif secretkey is not None and publickey is not None:
+            return SPHINCSSecretKey(algorithm, secretkey), SPHINCSPublicKey(algorithm, publickey)
+        else:
+            secretkey, publickey = _internal.sigkeygen(algorithm.value) # type: ignore
+            return SPHINCSSecretKey(algorithm, secretkey), SPHINCSPublicKey(algorithm, publickey) # type: ignore
+    elif isinstance(algorithm, Algorithm.UOV):
+        if secretkey is not None and publickey is None:
+            return UOVSecretKey(algorithm, secretkey)
+        elif publickey is not None and secretkey is None:
+            return UOVPublicKey(algorithm, publickey)
+        elif secretkey is not None and publickey is not None:
+            return UOVSecretKey(algorithm, secretkey), UOVPublicKey(algorithm, publickey)
+        else:
+            secretkey, publickey = _internal.sigkeygen(algorithm.value) # type: ignore
+            return UOVSecretKey(algorithm, secretkey), UOVPublicKey(algorithm, publickey) # type: ignore
+    else:
+        raise ValueError(f"Unsupported algorithm: {name}")

puantum/quantum/kem/__init__.py

@@ -0,0 +1,5 @@
+# IMPORT
+from puantum.quantum.kem.__internal__ import Algorithm, KeyPair
+
+# MAIN
+__all__: list[str] = ["Algorithm", "KeyPair"]

puantum/quantum/kem/__internal__.py

@@ -0,0 +1,526 @@
+# IMPORT
+from puantum import __internal__ as _internal # type: ignore
+import typing as _typing
+import enum as _enum
+
+# MAIN
+class Algorithm:
+    class BIKE(_enum.Enum):
+        BIKEL1 = "BikeL1"
+        BIKEL3 = "BikeL3"
+        BIKEL5 = "BikeL5"
+    #
+    class CLASSICMCELIECE(_enum.Enum):
+        CLASSICMCELIECE348864 = "ClassicMcEliece348864"
+        CLASSICMCELIECE348864F = "ClassicMcEliece348864f"
+        CLASSICMCELIECE460896 = "ClassicMcEliece460896"
+        CLASSICMCELIECE460896F = "ClassicMcEliece460896f"
+        CLASSICMCELIECE6688128 = "ClassicMcEliece6688128"
+        CLASSICMCELIECE6688128F = "ClassicMcEliece6688128f"
+        CLASSICMCELIECE6960119 = "ClassicMcEliece6960119"
+        CLASSICMCELIECE6960119F = "ClassicMcEliece6960119f"
+        CLASSICMCELIECE8192128 = "ClassicMcEliece8192128"
+        CLASSICMCELIECE8192128F = "ClassicMcEliece8192128f"
+    #
+    class HQC(_enum.Enum):
+        HQC128 = "Hqc128"
+        HQC192 = "Hqc192"
+        HQC256 = "Hqc256"
+    #
+    class KYBER(_enum.Enum):
+        KYBER512 = "Kyber512"
+        KYBER768 = "Kyber768"
+        KYBER1024 = "Kyber1024"
+    #
+    class MLKEM(_enum.Enum):
+        MLKEM512 = "MlKem512"
+        MLKEM768 = "MlKem768"
+        MLKEM1024 = "MlKem1024"
+    #
+    class NTRUPRIME(_enum.Enum):
+        NTRUPRIME = "NtruPrimeSntrup761"
+    #
+    class FRODOKEM(_enum.Enum):
+        FRODOKEM640AES = "FrodoKem640Aes"
+        FRODOKEM640SHAKE = "FrodoKem640Shake"
+        FRODOKEM976AES = "FrodoKem976Aes"
+        FRODOKEM976SHAKE = "FrodoKem976Shake"
+        FRODOKEM1344AES = "FrodoKem1344Aes"
+        FRODOKEM1344SHAKE = "FrodoKem1344Shake"
+
+
+
+class PublicKey:
+    def __init__(self, publickey: bytes) -> None:
+        if not isinstance(publickey, bytes):
+            raise TypeError("PublicKey Not Valid")
+        #
+        self.publickey = publickey
+        #
+        return None
+    #
+    def encapsulate(self) -> tuple[_typing.Any, _typing.Any]:
+        raise NotImplementedError()
+
+
+
+class BIKEPublicKey(PublicKey):
+    def __init__(self, name: Algorithm.BIKE, publickey: bytes) -> None:
+        if not isinstance(name, Algorithm.BIKE):
+            raise ValueError(f"Unsupported algorithm: {name}")
+        else:
+            super().__init__(publickey)
+        #
+        self._algorithm = name
+        #
+        return None
+    #
+    def encapsulate(self) -> tuple[bytes, bytes]:
+        sharedsecret, ciphertext = _internal.kemencapsulate(self._algorithm.value, self.publickey) # type: ignore
+        return sharedsecret, ciphertext # type: ignore
+
+
+
+class CLASSICMCELIECEPublicKey(PublicKey):
+    def __init__(self, name: Algorithm.CLASSICMCELIECE, publickey: bytes) -> None:
+        if not isinstance(name, Algorithm.CLASSICMCELIECE):
+            raise ValueError(f"Unsupported algorithm: {name}")
+        else:
+            super().__init__(publickey)
+        #
+        self._algorithm = name
+        #
+        return None
+    #
+    def encapsulate(self) -> tuple[bytes, bytes]:
+        sharedsecret, ciphertext = _internal.kemencapsulate(self._algorithm.value, self.publickey) # type: ignore
+        return sharedsecret, ciphertext # type: ignore
+
+
+
+class HQCPublicKey(PublicKey):
+    def __init__(self, name: Algorithm.HQC, publickey: bytes) -> None:
+        if not isinstance(name, Algorithm.HQC):
+            raise ValueError(f"Unsupported algorithm: {name}")
+        else:
+            super().__init__(publickey)
+        #
+        self._algorithm = name
+        #
+        return None
+    #
+    def encapsulate(self) -> tuple[bytes, bytes]:
+        sharedsecret, ciphertext = _internal.kemencapsulate(self._algorithm.value, self.publickey) # type: ignore
+        return sharedsecret, ciphertext # type: ignore
+
+
+
+class KYBERPublicKey(PublicKey):
+    def __init__(self, name: Algorithm.KYBER, publickey: bytes) -> None:
+        if not isinstance(name, Algorithm.KYBER):
+            raise ValueError(f"Unsupported algorithm: {name}")
+        else:
+            super().__init__(publickey)
+        #
+        self._algorithm = name
+        #
+        return None
+    #
+    def encapsulate(self) -> tuple[bytes, bytes]:
+        sharedsecret, ciphertext = _internal.kemencapsulate(self._algorithm.value, self.publickey) # type: ignore
+        return sharedsecret, ciphertext # type: ignore
+
+
+
+class MLKEMPublicKey(PublicKey):
+    def __init__(self, name: Algorithm.MLKEM, publickey: bytes) -> None:
+        if not isinstance(name, Algorithm.MLKEM):
+            raise ValueError(f"Unsupported algorithm: {name}")
+        else:
+            super().__init__(publickey)
+        #
+        self._algorithm = name
+        #
+        return None
+    #
+    def encapsulate(self) -> tuple[bytes, bytes]:
+        sharedsecret, ciphertext = _internal.kemencapsulate(self._algorithm.value, self.publickey) # type: ignore
+        return sharedsecret, ciphertext # type: ignore
+
+
+
+class NTRUPRIMEPublicKey(PublicKey):
+    def __init__(self, name: Algorithm.NTRUPRIME, publickey: bytes) -> None:
+        if not isinstance(name, Algorithm.NTRUPRIME):
+            raise ValueError(f"Unsupported algorithm: {name}")
+        else:
+            super().__init__(publickey)
+        #
+        self._algorithm = name
+        #
+        return None
+    #
+    def encapsulate(self) -> tuple[bytes, bytes]:
+        sharedsecret, ciphertext = _internal.kemencapsulate(self._algorithm.value, self.publickey) # type: ignore
+        return sharedsecret, ciphertext # type: ignore
+
+
+
+class FRODOKEMPublicKey(PublicKey):
+    def __init__(self, name: Algorithm.FRODOKEM, publickey: bytes) -> None:
+        if not isinstance(name, Algorithm.FRODOKEM):
+            raise ValueError(f"Unsupported algorithm: {name}")
+        else:
+            super().__init__(publickey)
+        #
+        self._algorithm = name
+        #
+        return None
+    #
+    def encapsulate(self) -> tuple[bytes, bytes]:
+        sharedsecret, ciphertext = _internal.kemencapsulate(self._algorithm.value, self.publickey) # type: ignore
+        return sharedsecret, ciphertext # type: ignore
+
+
+
+class SecretKey:
+    def __init__(self, secretkey: bytes) -> None:
+        if not isinstance(secretkey, bytes):
+            raise TypeError("SecretKey Not Valid")
+        #
+        self.secretkey = secretkey
+        #
+        return None
+    #
+    def decapsulate(self, ciphertext: _typing.Any) -> _typing.Any:
+        raise NotImplementedError()
+
+
+
+class BIKESecretKey(SecretKey):
+    def __init__(self, name: Algorithm.BIKE, secretkey: bytes) -> None:
+        if not isinstance(name, Algorithm.BIKE):
+            raise ValueError(f"Unsupported algorithm: {name}")
+        else:
+            super().__init__(secretkey)
+        #
+        self._algorithm = name
+        #
+        return None
+    #
+    def decapsulate(self, ciphertext: bytes) -> bytes:
+        sharedsecret: bytes = _internal.kemdecapsulate(self._algorithm.value, self.secretkey, ciphertext) # type: ignore
+        return sharedsecret # type: ignore
+
+
+
+class CLASSICMCELIECESecretKey(SecretKey):
+    def __init__(self, name: Algorithm.CLASSICMCELIECE, secretkey: bytes) -> None:
+        if not isinstance(name, Algorithm.CLASSICMCELIECE):
+            raise ValueError(f"Unsupported algorithm: {name}")
+        else:
+            super().__init__(secretkey)
+        #
+        self._algorithm = name
+        #
+        return None
+    #
+    def decapsulate(self, ciphertext: bytes) -> bytes:
+        sharedsecret: bytes = _internal.kemdecapsulate(self._algorithm.value, self.secretkey, ciphertext) # type: ignore
+        return sharedsecret # type: ignore
+
+
+
+class HQCSecretKey(SecretKey):
+    def __init__(self, name: Algorithm.HQC, secretkey: bytes) -> None:
+        if not isinstance(name, Algorithm.HQC):
+            raise ValueError(f"Unsupported algorithm: {name}")
+        else:
+            super().__init__(secretkey)
+        #
+        self._algorithm = name
+        #
+        return None
+    #
+    def decapsulate(self, ciphertext: bytes) -> bytes:
+        sharedsecret: bytes = _internal.kemdecapsulate(self._algorithm.value, self.secretkey, ciphertext) # type: ignore
+        return sharedsecret # type: ignore
+
+
+
+class KYBERSecretKey(SecretKey):
+    def __init__(self, name: Algorithm.KYBER, secretkey: bytes) -> None:
+        if not isinstance(name, Algorithm.KYBER):
+            raise ValueError(f"Unsupported algorithm: {name}")
+        else:
+            super().__init__(secretkey)
+        #
+        self._algorithm = name
+        #
+        return None
+    #
+    def decapsulate(self, ciphertext: bytes) -> bytes:
+        sharedsecret: bytes = _internal.kemdecapsulate(self._algorithm.value, self.secretkey, ciphertext) # type: ignore
+        return sharedsecret # type: ignore
+
+
+
+class MLKEMSecretKey(SecretKey):
+    def __init__(self, name: Algorithm.MLKEM, secretkey: bytes) -> None:
+        if not isinstance(name, Algorithm.MLKEM):
+            raise ValueError(f"Unsupported algorithm: {name}")
+        else:
+            super().__init__(secretkey)
+        #
+        self._algorithm = name
+        #
+        return None
+    #
+    def decapsulate(self, ciphertext: bytes) -> bytes:
+        sharedsecret: bytes = _internal.kemdecapsulate(self._algorithm.value, self.secretkey, ciphertext) # type: ignore
+        return sharedsecret # type: ignore
+
+
+
+class NTRUPRIMESecretKey(SecretKey):
+    def __init__(self, name: Algorithm.NTRUPRIME, secretkey: bytes) -> None:
+        if not isinstance(name, Algorithm.NTRUPRIME):
+            raise ValueError(f"Unsupported algorithm: {name}")
+        else:
+            super().__init__(secretkey)
+        #
+        self._algorithm = name
+        #
+        return None
+    #
+    def decapsulate(self, ciphertext: bytes) -> bytes:
+        sharedsecret: bytes = _internal.kemdecapsulate(self._algorithm.value, self.secretkey, ciphertext) # type: ignore
+        return sharedsecret # type: ignore
+
+
+
+class FRODOKEMSecretKey(SecretKey):
+    def __init__(self, name: Algorithm.FRODOKEM, secretkey: bytes) -> None:
+        if not isinstance(name, Algorithm.FRODOKEM):
+            raise ValueError(f"Unsupported algorithm: {name}")
+        else:
+            super().__init__(secretkey)
+        #
+        self._algorithm = name
+        #
+        return None
+    #
+    def decapsulate(self, ciphertext: bytes) -> bytes:
+        sharedsecret: bytes = _internal.kemdecapsulate(self._algorithm.value, self.secretkey, ciphertext) # type: ignore
+        return sharedsecret # type: ignore
+
+
+
+@_typing.overload
+def KeyPair(
+    name: Algorithm,
+    *,
+    secretkey: bytes,
+    publickey: bytes
+) -> tuple[SecretKey, PublicKey]: ...
+@_typing.overload
+def KeyPair(name: Algorithm, *, secretkey: bytes) -> SecretKey: ...
+@_typing.overload
+def KeyPair(name: Algorithm, *, publickey: bytes) -> PublicKey: ...
+@_typing.overload
+def KeyPair(name: Algorithm) -> tuple[SecretKey, PublicKey]: ...
+
+
+
+@_typing.overload
+def KeyPair(
+    name: Algorithm.BIKE,
+    *,
+    secretkey: bytes,
+    publickey: bytes
+) -> tuple[BIKESecretKey, BIKEPublicKey]: ...
+@_typing.overload
+def KeyPair(name: Algorithm.BIKE, *, secretkey: bytes) -> BIKESecretKey: ...
+@_typing.overload
+def KeyPair(name: Algorithm.BIKE, *, publickey: bytes) -> BIKEPublicKey: ...
+@_typing.overload
+def KeyPair(name: Algorithm.BIKE) -> tuple[BIKESecretKey, BIKEPublicKey]: ...
+
+
+
+@_typing.overload
+def KeyPair(
+    name: Algorithm.CLASSICMCELIECE,
+    *,
+    secretkey: bytes,
+    publickey: bytes
+) -> tuple[CLASSICMCELIECESecretKey, CLASSICMCELIECEPublicKey]: ...
+@_typing.overload
+def KeyPair(name: Algorithm.CLASSICMCELIECE, *, secretkey: bytes) -> CLASSICMCELIECESecretKey: ...
+@_typing.overload
+def KeyPair(name: Algorithm.CLASSICMCELIECE, *, publickey: bytes) -> CLASSICMCELIECEPublicKey: ...
+@_typing.overload
+def KeyPair(name: Algorithm.CLASSICMCELIECE) -> tuple[CLASSICMCELIECESecretKey, CLASSICMCELIECEPublicKey]: ...
+
+
+
+@_typing.overload
+def KeyPair(
+    name: Algorithm.HQC,
+    *,
+    secretkey: bytes,
+    publickey: bytes
+) -> tuple[HQCSecretKey, HQCPublicKey]: ...
+@_typing.overload
+def KeyPair(name: Algorithm.HQC, *, secretkey: bytes) -> HQCSecretKey: ...
+@_typing.overload
+def KeyPair(name: Algorithm.HQC, *, publickey: bytes) -> HQCPublicKey: ...
+@_typing.overload
+def KeyPair(name: Algorithm.HQC) -> tuple[HQCSecretKey, HQCPublicKey]: ...
+
+
+
+@_typing.overload
+def KeyPair(
+    name: Algorithm.KYBER,
+    *,
+    secretkey: bytes,
+    publickey: bytes
+) -> tuple[KYBERSecretKey, KYBERPublicKey]: ...
+@_typing.overload
+def KeyPair(name: Algorithm.KYBER, *, secretkey: bytes) -> KYBERSecretKey: ...
+@_typing.overload
+def KeyPair(name: Algorithm.KYBER, *, publickey: bytes) -> KYBERPublicKey: ...
+@_typing.overload
+def KeyPair(name: Algorithm.KYBER) -> tuple[KYBERSecretKey, KYBERPublicKey]: ...
+
+
+
+@_typing.overload
+def KeyPair(
+    name: Algorithm.MLKEM,
+    *,
+    secretkey: bytes,
+    publickey: bytes
+) -> tuple[MLKEMSecretKey, MLKEMPublicKey]: ...
+@_typing.overload
+def KeyPair(name: Algorithm.MLKEM, *, secretkey: bytes) -> MLKEMSecretKey: ...
+@_typing.overload
+def KeyPair(name: Algorithm.MLKEM, *, publickey: bytes) -> MLKEMPublicKey: ...
+@_typing.overload
+def KeyPair(name: Algorithm.MLKEM) -> tuple[MLKEMSecretKey, MLKEMPublicKey]: ...
+
+
+
+@_typing.overload
+def KeyPair(
+    name: Algorithm.NTRUPRIME,
+    *,
+    secretkey: bytes,
+    publickey: bytes
+) -> tuple[NTRUPRIMESecretKey, NTRUPRIMEPublicKey]: ...
+@_typing.overload
+def KeyPair(name: Algorithm.NTRUPRIME, *, secretkey: bytes) -> NTRUPRIMESecretKey: ...
+@_typing.overload
+def KeyPair(name: Algorithm.NTRUPRIME, *, publickey: bytes) -> NTRUPRIMEPublicKey: ...
+@_typing.overload
+def KeyPair(name: Algorithm.NTRUPRIME) -> tuple[NTRUPRIMESecretKey, NTRUPRIMEPublicKey]: ...
+
+
+
+@_typing.overload
+def KeyPair(
+    name: Algorithm.FRODOKEM,
+    *,
+    secretkey: bytes,
+    publickey: bytes
+) -> tuple[FRODOKEMSecretKey, FRODOKEMPublicKey]: ...
+@_typing.overload
+def KeyPair(name: Algorithm.FRODOKEM, *, secretkey: bytes) -> FRODOKEMSecretKey: ...
+@_typing.overload
+def KeyPair(name: Algorithm.FRODOKEM, *, publickey: bytes) -> FRODOKEMPublicKey: ...
+@_typing.overload
+def KeyPair(name: Algorithm.FRODOKEM) -> tuple[FRODOKEMSecretKey, FRODOKEMPublicKey]: ...
+
+
+
+Algorithms = Algorithm.BIKE | Algorithm.CLASSICMCELIECE | Algorithm.HQC | Algorithm.KYBER | Algorithm.MLKEM | Algorithm.NTRUPRIME | Algorithm.FRODOKEM
+def KeyPair(
+        name: Algorithm | Algorithms,
+        *,
+        secretkey: bytes | None = None,
+        publickey: bytes | None = None
+    ) -> tuple[SecretKey, PublicKey] | SecretKey | PublicKey:
+    algorithm = name
+    if isinstance(algorithm, Algorithm.BIKE):
+        if secretkey is not None and publickey is None:
+            return BIKESecretKey(algorithm, secretkey)
+        elif publickey is not None and secretkey is None:
+            return BIKEPublicKey(algorithm, publickey)
+        elif secretkey is not None and publickey is not None:
+            return BIKESecretKey(algorithm, secretkey), BIKEPublicKey(algorithm, publickey)
+        else:
+            secretkey, publickey = _internal.kemkeygen(algorithm.value) # type: ignore
+            return BIKESecretKey(algorithm, secretkey), BIKEPublicKey(algorithm, publickey) # type: ignore
+    elif isinstance(algorithm, Algorithm.CLASSICMCELIECE):
+        if secretkey is not None and publickey is None:
+            return CLASSICMCELIECESecretKey(algorithm, secretkey)
+        elif publickey is not None and secretkey is None:
+            return CLASSICMCELIECEPublicKey(algorithm, publickey)
+        elif secretkey is not None and publickey is not None:
+            return CLASSICMCELIECESecretKey(algorithm, secretkey), CLASSICMCELIECEPublicKey(algorithm, publickey)
+        else:
+            secretkey, publickey = _internal.kemkeygen(algorithm.value) # type: ignore
+            return CLASSICMCELIECESecretKey(algorithm, secretkey), CLASSICMCELIECEPublicKey(algorithm, publickey) # type: ignore
+    elif isinstance(algorithm, Algorithm.HQC):
+        if secretkey is not None and publickey is None:
+            return HQCSecretKey(algorithm, secretkey)
+        elif publickey is not None and secretkey is None:
+            return HQCPublicKey(algorithm, publickey)
+        elif secretkey is not None and publickey is not None:
+            return HQCSecretKey(algorithm, secretkey), HQCPublicKey(algorithm, publickey)
+        else:
+            secretkey, publickey = _internal.kemkeygen(algorithm.value) # type: ignore
+            return HQCSecretKey(algorithm, secretkey), HQCPublicKey(algorithm, publickey) # type: ignore
+    elif isinstance(algorithm, Algorithm.KYBER):
+        if secretkey is not None and publickey is None:
+            return KYBERSecretKey(algorithm, secretkey)
+        elif publickey is not None and secretkey is None:
+            return KYBERPublicKey(algorithm, publickey)
+        elif secretkey is not None and publickey is not None:
+            return KYBERSecretKey(algorithm, secretkey), KYBERPublicKey(algorithm, publickey)
+        else:
+            secretkey, publickey = _internal.kemkeygen(algorithm.value) # type: ignore
+            return KYBERSecretKey(algorithm, secretkey), KYBERPublicKey(algorithm, publickey) # type: ignore
+    elif isinstance(algorithm, Algorithm.MLKEM):
+        if secretkey is not None and publickey is None:
+            return MLKEMSecretKey(algorithm, secretkey)
+        elif publickey is not None and secretkey is None:
+            return MLKEMPublicKey(algorithm, publickey)
+        elif secretkey is not None and publickey is not None:
+            return MLKEMSecretKey(algorithm, secretkey), MLKEMPublicKey(algorithm, publickey)
+        else:
+            secretkey, publickey = _internal.kemkeygen(algorithm.value) # type: ignore
+            return MLKEMSecretKey(algorithm, secretkey), MLKEMPublicKey(algorithm, publickey) # type: ignore
+    elif isinstance(algorithm, Algorithm.NTRUPRIME):
+        if secretkey is not None and publickey is None:
+            return NTRUPRIMESecretKey(algorithm, secretkey)
+        elif publickey is not None and secretkey is None:
+            return NTRUPRIMEPublicKey(algorithm, publickey)
+        elif secretkey is not None and publickey is not None:
+            return NTRUPRIMESecretKey(algorithm, secretkey), NTRUPRIMEPublicKey(algorithm, publickey)
+        else:
+            secretkey, publickey = _internal.kemkeygen(algorithm.value) # type: ignore
+            return NTRUPRIMESecretKey(algorithm, secretkey), NTRUPRIMEPublicKey(algorithm, publickey) # type: ignore
+    elif isinstance(algorithm, Algorithm.FRODOKEM):
+        if secretkey is not None and publickey is None:
+            return FRODOKEMSecretKey(algorithm, secretkey)
+        elif publickey is not None and secretkey is None:
+            return FRODOKEMPublicKey(algorithm, publickey)
+        elif secretkey is not None and publickey is not None:
+            return FRODOKEMSecretKey(algorithm, secretkey), FRODOKEMPublicKey(algorithm, publickey)
+        else:
+            secretkey, publickey = _internal.kemkeygen(algorithm.value) # type: ignore
+            return FRODOKEMSecretKey(algorithm, secretkey), FRODOKEMPublicKey(algorithm, publickey) # type: ignore
+    else:
+        raise ValueError(f"Unsupported algorithm: {name}")

puantum-1.2.3.dist-info/METADATA

@@ -0,0 +1,66 @@
+Metadata-Version: 2.4
+Name: puantum
+Version: 1.2.3
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Rust
+Classifier: Operating System :: OS Independent
+Classifier: License :: Public Domain
+Classifier: License :: OSI Approved :: The Unlicense (Unlicense)
+License-File: license.md
+Summary: Python Cryptography
+Keywords: python,cryptography,quantum,security
+Author-email: Anonymous <217687495+1xfakebit@users.noreply.github.com>
+License: Unlicense
+Description-Content-Type: text/markdown
+Project-URL: source, https://github.com/1xfakebit/puantum
+Project-URL: x, https://x.com/1xfakebit
+
+# 🔐 Python Cryptography
+
+A blazing-fast cryptography library for Python, built on Rust.
+
+Puantum supports an extensive set of **post-quantum** key encapsulation mechanisms (KEM) and digital signature algorithms (DSA), and will soon support **classic cryptography** as well.
+
+---
+## ⚡ Features
+- ✅ Dozens of NIST PQC candidates 
+- 🦀 Rust core for speed and safety
+- 📦 Easy installation via [`pip`](https://pip.pypa.io)
+---
+
+### 🧬 Supported Algorithms
+
+### 🛡️ KEM
+- #### Bike
+- #### ClassicMcEliece
+- #### Hqc
+- #### Kyber
+- #### MLKEM
+- #### NtruPrime
+- #### FrodoKem
+
+### ✍️ DSA
+- #### Cross
+- #### Dilithium
+- #### Falcon
+- #### Mayo
+- #### MLDSA
+- #### Sphincs
+- #### Uov
+
+### 🚧 Coming Soon
+- #### AES, ChaCha20, XChaCha20
+- #### RSA, EC
+- #### Argon2, Bcrypt
+
+### 📦 Install
+```shell
+pip install puantum
+```
+#### or from source:
+```shell
+make python
+```
+
+### 🥳 Enjoy!
+

puantum-1.2.3.dist-info/RECORD

@@ -0,0 +1,12 @@
+puantum-1.2.3.dist-info/METADATA,sha256=IcjYtA9_vDMTDNE7in_Z_rOi7zO7n-CePcjpZFIgeUs,1524
+puantum-1.2.3.dist-info/WHEEL,sha256=IPzRd0nigP4r3GK-lmtM2DKCRPiRfyNhNj4tmNbAOTQ,108
+puantum-1.2.3.dist-info/licenses/license.md,sha256=tQZYOMusRS38hVum5uAxSBrSxoQG9w0h6tkyE3RlPmw,1212
+puantum/__init__.py,sha256=DqzIK80d6ihVj9p2qBPJwBjM0V3kl6MRRjKowVB61Ak,8
+puantum/__internal__.cpython-312-x86_64-linux-gnu.so,sha256=vBEtdfLDAmoj98xYKIbEWH_2FDQn-RxlhRadKngIZzI,8279488
+puantum/classic/__init__.py,sha256=Dlr1m0uJio3HWH8_gkdhnQS87KUZfUw5wX4tXQtbvWQ,35
+puantum/quantum/__init__.py,sha256=DqzIK80d6ihVj9p2qBPJwBjM0V3kl6MRRjKowVB61Ak,8
+puantum/quantum/dsa/__init__.py,sha256=r9eRKYMhU7KC2nwb1hW26KVpwz2XuXDQBzW3m36yCkM,127
+puantum/quantum/dsa/__internal__.py,sha256=HWON0ta7EV09NXbXSh7rNKbUsTdeg9Wf5-oQcRan7Eo,19533
+puantum/quantum/kem/__init__.py,sha256=U3TwWZ7eIYQgPeMXN2pfQvaqdWQimQTP-KDosfFvwk0,127
+puantum/quantum/kem/__internal__.py,sha256=es__oqu6tzaRhXx6x8J5twb3CK-9zXCsPmeNRPMAfow,19144
+puantum-1.2.3.dist-info/RECORD,,

puantum-1.2.3.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: maturin (1.9.0)
+Root-Is-Purelib: false
+Tag: cp312-cp312-manylinux_2_34_x86_64

puantum-1.2.3.dist-info/licenses/license.md

@@ -0,0 +1,24 @@
+This is free and unencumbered software released into the public domain.
+
+Anyone is free to copy, modify, publish, use, compile, sell, or
+distribute this software, either in source code form or as a compiled
+binary, for any purpose, commercial or non-commercial, and by any
+means.
+
+In jurisdictions that recognize copyright laws, the author or authors
+of this software dedicate any and all copyright interest in the
+software to the public domain. We make this dedication for the benefit
+of the public at large and to the detriment of our heirs and
+successors. We intend this dedication to be an overt act of
+relinquishment in perpetuity of all present and future rights to this
+software under copyright law.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+IN NO EVENT SHALL THE AUTHORS BE LIABLE FOR ANY CLAIM, DAMAGES OR
+OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
+ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+OTHER DEALINGS IN THE SOFTWARE.
+
+For more information, please refer to <https://unlicense.org/>