puantum 1.1.1__cp313-cp313-win_amd64.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,498 @@
+# 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 Signature:
+    def __init__(self, signature: bytes) -> None:
+        if not isinstance(signature, bytes):
+            raise TypeError("Signature Not Valid")
+        #
+        self.signature = signature
+        #
+        return None
+
+
+
+class CROSSSignature(Signature):
+    def __init__(self, name: Algorithm.CROSS, signature: bytes) -> None:
+        if not isinstance(name, Algorithm.CROSS):
+            raise ValueError(f"Unsupported algorithm: {name}")
+        else:
+            super().__init__(signature)
+        #
+        return None
+
+
+
+class DILITHIUMSignature(Signature):
+    def __init__(self, name: Algorithm.DILITHIUM, signature: bytes) -> None:
+        if not isinstance(name, Algorithm.DILITHIUM):
+            raise ValueError(f"Unsupported algorithm: {name}")
+        else:
+            super().__init__(signature)
+        #
+        return None
+
+
+
+class FALCONSignature(Signature):
+    def __init__(self, name: Algorithm.FALCON, signature: bytes) -> None:
+        if not isinstance(name, Algorithm.FALCON):
+            raise ValueError(f"Unsupported algorithm: {name}")
+        else:
+            super().__init__(signature)
+        #
+        return None
+
+
+
+class MAYOSignature(Signature):
+    def __init__(self, name: Algorithm.MAYO, signature: bytes) -> None:
+        if not isinstance(name, Algorithm.MAYO):
+            raise ValueError(f"Unsupported algorithm: {name}")
+        else:
+            super().__init__(signature)
+        #
+        return None
+
+
+
+class MLDSASignature(Signature):
+    def __init__(self, name: Algorithm.MLDSA, signature: bytes) -> None:
+        if not isinstance(name, Algorithm.MLDSA):
+            raise ValueError(f"Unsupported algorithm: {name}")
+        else:
+            super().__init__(signature)
+        #
+        return None
+
+
+
+class SPHINCSSignature(Signature):
+    def __init__(self, name: Algorithm.SPHINCS, signature: bytes) -> None:
+        if not isinstance(name, Algorithm.SPHINCS):
+            raise ValueError(f"Unsupported algorithm: {name}")
+        else:
+            super().__init__(signature)
+        #
+        return None
+
+
+class UOVSignature(Signature):
+    def __init__(self, name: Algorithm.UOV, signature: bytes) -> None:
+        if not isinstance(name, Algorithm.UOV):
+            raise ValueError(f"Unsupported algorithm: {name}")
+        else:
+            super().__init__(signature)
+        #
+        return None
+
+
+
+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: CROSSSignature, message: bytes) -> bool:
+        result: bool = _internal.sigverify(self._algorithm.value, self.publickey, signature.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: DILITHIUMSignature, message: bytes) -> bool:
+        result: bool = _internal.sigverify(self._algorithm.value, self.publickey, signature.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: FALCONSignature, message: bytes) -> bool:
+        result: bool = _internal.sigverify(self._algorithm.value, self.publickey, signature.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: MAYOSignature, message: bytes) -> bool:
+        result: bool = _internal.sigverify(self._algorithm.value, self.publickey, signature.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: MLDSASignature, message: bytes) -> bool:
+        result: bool = _internal.sigverify(self._algorithm.value, self.publickey, signature.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: SPHINCSSignature, message: bytes) -> bool:
+        result: bool = _internal.sigverify(self._algorithm.value, self.publickey, signature.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: UOVSignature, message: bytes) -> bool:
+        result: bool = _internal.sigverify(self._algorithm.value, self.publickey, signature.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) -> CROSSSignature:
+        signature: bytes = _internal.sigsign(self._algorithm.value, self.secretkey, message) # type: ignore
+        return CROSSSignature(self._algorithm, 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) -> DILITHIUMSignature:
+        signature: bytes = _internal.sigsign(self._algorithm.value, self.secretkey, message) # type: ignore
+        return DILITHIUMSignature(self._algorithm, 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) -> FALCONSignature:
+        signature: bytes = _internal.sigsign(self._algorithm.value, self.secretkey, message) # type: ignore
+        return FALCONSignature(self._algorithm, 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) -> MAYOSignature:
+        signature: bytes = _internal.sigsign(self._algorithm.value, self.secretkey, message) # type: ignore
+        return MAYOSignature(self._algorithm, 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) -> MLDSASignature:
+        signature: bytes = _internal.sigsign(self._algorithm.value, self.secretkey, message) # type: ignore
+        return MLDSASignature(self._algorithm, 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) -> SPHINCSSignature:
+        signature: bytes = _internal.sigsign(self._algorithm.value, self.secretkey, message) # type: ignore
+        return SPHINCSSignature(self._algorithm, 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) -> UOVSignature:
+        signature: bytes = _internal.sigsign(self._algorithm.value, self.secretkey, message) # type: ignore
+        return UOVSignature(self._algorithm, signature) # type: ignore
+
+
+
+Algorithms = Algorithm | Algorithm.CROSS | Algorithm.DILITHIUM | Algorithm.FALCON | Algorithm.MAYO | Algorithm.MLDSA | Algorithm.SPHINCS | Algorithm.UOV
+
+
+
+@_typing.overload
+def KeyPair(name: Algorithm) -> tuple[SecretKey, PublicKey]: ...
+
+
+@_typing.overload
+def KeyPair(name: Algorithm.CROSS) -> tuple[CROSSSecretKey, CROSSPublicKey]: ...
+
+
+
+@_typing.overload
+def KeyPair(name: Algorithm.DILITHIUM) -> tuple[DILITHIUMSecretKey, DILITHIUMPublicKey]: ...
+
+
+
+@_typing.overload
+def KeyPair(name: Algorithm.FALCON) -> tuple[FALCONSecretKey, FALCONPublicKey]: ...
+
+
+
+@_typing.overload
+def KeyPair(name: Algorithm.MAYO) -> tuple[MAYOSecretKey, MAYOPublicKey]: ...
+
+
+
+@_typing.overload
+def KeyPair(name: Algorithm.MLDSA) -> tuple[MLDSASecretKey, MLDSAPublicKey]: ...
+
+
+
+@_typing.overload
+def KeyPair(name: Algorithm.SPHINCS) -> tuple[SPHINCSSecretKey, SPHINCSPublicKey]: ...
+
+
+
+@_typing.overload
+def KeyPair(name: Algorithm.UOV) -> tuple[UOVSecretKey, UOVPublicKey]: ...
+
+
+
+def KeyPair(name: Algorithms) -> tuple[SecretKey, PublicKey]:
+    algorithm = name
+    if isinstance(algorithm, Algorithm.CROSS):
+        secretkey, publickey = _internal.sigkeygen(algorithm.value) # type: ignore
+        return CROSSSecretKey(algorithm, secretkey), CROSSPublicKey(algorithm, publickey) # type: ignore
+    elif isinstance(algorithm, Algorithm.DILITHIUM):
+        secretkey, publickey = _internal.sigkeygen(algorithm.value) # type: ignore
+        return DILITHIUMSecretKey(algorithm, secretkey), DILITHIUMPublicKey(algorithm, publickey) # type: ignore
+    elif isinstance(algorithm, Algorithm.FALCON):
+        secretkey, publickey = _internal.sigkeygen(algorithm.value) # type: ignore
+        return FALCONSecretKey(algorithm, secretkey), FALCONPublicKey(algorithm, publickey) # type: ignore
+    elif isinstance(algorithm, Algorithm.MAYO):
+        secretkey, publickey = _internal.sigkeygen(algorithm.value) # type: ignore
+        return MAYOSecretKey(algorithm, secretkey), MAYOPublicKey(algorithm, publickey) # type: ignore
+    elif isinstance(algorithm, Algorithm.MLDSA):
+        secretkey, publickey = _internal.sigkeygen(algorithm.value) # type: ignore
+        return MLDSASecretKey(algorithm, secretkey), MLDSAPublicKey(algorithm, publickey) # type: ignore
+    elif isinstance(algorithm, Algorithm.SPHINCS):
+        secretkey, publickey = _internal.sigkeygen(algorithm.value) # type: ignore
+        return SPHINCSSecretKey(algorithm, secretkey), SPHINCSPublicKey(algorithm, publickey) # type: ignore
+    elif isinstance(algorithm, Algorithm.UOV):
+        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,563 @@
+# 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 Ciphertext:
+    def __init__(self, ciphertext: bytes) -> None:
+        if not isinstance(ciphertext, bytes):
+            raise TypeError("Ciphertext Not Valid")
+        #
+        self.ciphertext = ciphertext
+        #
+        return None
+
+
+
+class BIKECiphertext(Ciphertext):
+    def __init__(self, name: Algorithm.BIKE, ciphertext: bytes) -> None:
+        if not isinstance(name, Algorithm.BIKE):
+            raise ValueError(f"Unsupported algorithm: {name}")
+        else:
+            super().__init__(ciphertext)
+        #
+        return None
+
+
+
+class CLASSICMCELIECECiphertext(Ciphertext):
+    def __init__(self, name: Algorithm.CLASSICMCELIECE, ciphertext: bytes) -> None:
+        if not isinstance(name, Algorithm.CLASSICMCELIECE):
+            raise ValueError(f"Unsupported algorithm: {name}")
+        else:
+            super().__init__(ciphertext)
+        #
+        return None
+
+
+
+class HQCCiphertext(Ciphertext):
+    def __init__(self, name: Algorithm.HQC, ciphertext: bytes) -> None:
+        if not isinstance(name, Algorithm.HQC):
+            raise ValueError(f"Unsupported algorithm: {name}")
+        else:
+            super().__init__(ciphertext)
+        #
+        return None
+
+
+
+class KYBERCiphertext(Ciphertext):
+    def __init__(self, name: Algorithm.KYBER, ciphertext: bytes) -> None:
+        if not isinstance(name, Algorithm.KYBER):
+            raise ValueError(f"Unsupported algorithm: {name}")
+        else:
+            super().__init__(ciphertext)
+        #
+        return None
+
+
+
+class MLKEMCiphertext(Ciphertext):
+    def __init__(self, name: Algorithm.MLKEM, ciphertext: bytes) -> None:
+        if not isinstance(name, Algorithm.MLKEM):
+            raise ValueError(f"Unsupported algorithm: {name}")
+        else:
+            super().__init__(ciphertext)
+        #
+        return None
+
+
+
+class NTRUPRIMECiphertext(Ciphertext):
+    def __init__(self, name: Algorithm.NTRUPRIME, ciphertext: bytes) -> None:
+        if not isinstance(name, Algorithm.NTRUPRIME):
+            raise ValueError(f"Unsupported algorithm: {name}")
+        else:
+            super().__init__(ciphertext)
+        #
+        return None
+
+
+
+class FRODOKEMCiphertext(Ciphertext):
+    def __init__(self, name: Algorithm.FRODOKEM, ciphertext: bytes) -> None:
+        if not isinstance(name, Algorithm.FRODOKEM):
+            raise ValueError(f"Unsupported algorithm: {name}")
+        else:
+            super().__init__(ciphertext)
+        #
+        return None
+
+
+
+class SharedSecret:
+    def __init__(self, sharedsecret: bytes) -> None:
+        if not isinstance(sharedsecret, bytes):
+            raise TypeError("SharedSecret Not Valid")
+        #
+        self.sharedsecret = sharedsecret
+        #
+        return None
+
+
+
+class BIKESharedSecret(SharedSecret):
+    def __init__(self, name: Algorithm.BIKE, sharedsecret: bytes) -> None:
+        if not isinstance(name, Algorithm.BIKE):
+            raise ValueError(f"Unsupported algorithm: {name}")
+        else:
+            super().__init__(sharedsecret)
+        #
+        return None
+
+
+
+class CLASSICMCELIECESharedSecret(SharedSecret):
+    def __init__(self, name: Algorithm.CLASSICMCELIECE, sharedsecret: bytes) -> None:
+        if not isinstance(name, Algorithm.CLASSICMCELIECE):
+            raise ValueError(f"Unsupported algorithm: {name}")
+        else:
+            super().__init__(sharedsecret)
+        #
+        return None
+
+
+
+class HQCSharedSecret(SharedSecret):
+    def __init__(self, name: Algorithm.HQC, sharedsecret: bytes) -> None:
+        if not isinstance(name, Algorithm.HQC):
+            raise ValueError(f"Unsupported algorithm: {name}")
+        else:
+            super().__init__(sharedsecret)
+        #
+        return None
+
+
+
+class KYBERSharedSecret(SharedSecret):
+    def __init__(self, name: Algorithm.KYBER, sharedsecret: bytes) -> None:
+        if not isinstance(name, Algorithm.KYBER):
+            raise ValueError(f"Unsupported algorithm: {name}")
+        else:
+            super().__init__(sharedsecret)
+        #
+        return None
+
+
+
+class MLKEMSharedSecret(SharedSecret):
+    def __init__(self, name: Algorithm.MLKEM, sharedsecret: bytes) -> None:
+        if not isinstance(name, Algorithm.MLKEM):
+            raise ValueError(f"Unsupported algorithm: {name}")
+        else:
+            super().__init__(sharedsecret)
+        #
+        return None
+
+
+
+class NTRUPRIMESharedSecret(SharedSecret):
+    def __init__(self, name: Algorithm.NTRUPRIME, sharedsecret: bytes) -> None:
+        if not isinstance(name, Algorithm.NTRUPRIME):
+            raise ValueError(f"Unsupported algorithm: {name}")
+        else:
+            super().__init__(sharedsecret)
+        #
+        return None
+
+
+
+class FRODOKEMSharedSecret(SharedSecret):
+    def __init__(self, name: Algorithm.FRODOKEM, sharedsecret: bytes) -> None:
+        if not isinstance(name, Algorithm.FRODOKEM):
+            raise ValueError(f"Unsupported algorithm: {name}")
+        else:
+            super().__init__(sharedsecret)
+        #
+        return None
+
+
+
+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[BIKESharedSecret, BIKECiphertext]:
+        sharedsecret, ciphertext = _internal.kemencapsulate(self._algorithm.value, self.publickey) # type: ignore
+        return BIKESharedSecret(self._algorithm, sharedsecret), BIKECiphertext(self._algorithm, 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[CLASSICMCELIECESharedSecret, CLASSICMCELIECECiphertext]:
+        sharedsecret, ciphertext = _internal.kemencapsulate(self._algorithm.value, self.publickey) # type: ignore
+        return CLASSICMCELIECESharedSecret(self._algorithm, sharedsecret), CLASSICMCELIECECiphertext(self._algorithm, 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[HQCSharedSecret, HQCCiphertext]:
+        sharedsecret, ciphertext = _internal.kemencapsulate(self._algorithm.value, self.publickey) # type: ignore
+        return HQCSharedSecret(self._algorithm, sharedsecret), HQCCiphertext(self._algorithm, 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[KYBERSharedSecret, KYBERCiphertext]:
+        sharedsecret, ciphertext = _internal.kemencapsulate(self._algorithm.value, self.publickey) # type: ignore
+        return KYBERSharedSecret(self._algorithm, sharedsecret), KYBERCiphertext(self._algorithm, 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[MLKEMSharedSecret, MLKEMCiphertext]:
+        sharedsecret, ciphertext = _internal.kemencapsulate(self._algorithm.value, self.publickey) # type: ignore
+        return MLKEMSharedSecret(self._algorithm, sharedsecret), MLKEMCiphertext(self._algorithm, 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[NTRUPRIMESharedSecret, NTRUPRIMECiphertext]:
+        sharedsecret, ciphertext = _internal.kemencapsulate(self._algorithm.value, self.publickey) # type: ignore
+        return NTRUPRIMESharedSecret(self._algorithm, sharedsecret), NTRUPRIMECiphertext(self._algorithm, 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[FRODOKEMSharedSecret, FRODOKEMCiphertext]:
+        sharedsecret, ciphertext = _internal.kemencapsulate(self._algorithm.value, self.publickey) # type: ignore
+        return FRODOKEMSharedSecret(self._algorithm, sharedsecret), FRODOKEMCiphertext(self._algorithm, 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: BIKECiphertext) -> BIKESharedSecret:
+        sharedsecret: bytes = _internal.kemdecapsulate(self._algorithm.value, self.secretkey, ciphertext.ciphertext) # type: ignore
+        return BIKESharedSecret(self._algorithm, 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: CLASSICMCELIECECiphertext) -> CLASSICMCELIECESharedSecret:
+        sharedsecret: bytes = _internal.kemdecapsulate(self._algorithm.value, self.secretkey, ciphertext.ciphertext) # type: ignore
+        return CLASSICMCELIECESharedSecret(self._algorithm, 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: HQCCiphertext) -> HQCSharedSecret:
+        sharedsecret: bytes = _internal.kemdecapsulate(self._algorithm.value, self.secretkey, ciphertext.ciphertext) # type: ignore
+        return HQCSharedSecret(self._algorithm, 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: KYBERCiphertext) -> KYBERSharedSecret:
+        sharedsecret: bytes = _internal.kemdecapsulate(self._algorithm.value, self.secretkey, ciphertext.ciphertext) # type: ignore
+        return KYBERSharedSecret(self._algorithm, 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: MLKEMCiphertext) -> MLKEMSharedSecret:
+        sharedsecret: bytes = _internal.kemdecapsulate(self._algorithm.value, self.secretkey, ciphertext.ciphertext) # type: ignore
+        return MLKEMSharedSecret(self._algorithm, 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: NTRUPRIMECiphertext) -> NTRUPRIMESharedSecret:
+        sharedsecret: bytes = _internal.kemdecapsulate(self._algorithm.value, self.secretkey, ciphertext.ciphertext) # type: ignore
+        return NTRUPRIMESharedSecret(self._algorithm, 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: FRODOKEMCiphertext) -> FRODOKEMSharedSecret:
+        sharedsecret: bytes = _internal.kemdecapsulate(self._algorithm.value, self.secretkey, ciphertext.ciphertext) # type: ignore
+        return FRODOKEMSharedSecret(self._algorithm, sharedsecret) # type: ignore
+
+
+
+Algorithms = Algorithm | Algorithm.BIKE | Algorithm.CLASSICMCELIECE | Algorithm.HQC | Algorithm.KYBER | Algorithm.MLKEM | Algorithm.NTRUPRIME | Algorithm.FRODOKEM
+
+
+
+@_typing.overload
+def KeyPair(name: Algorithm) -> tuple[SecretKey, PublicKey]: ...
+
+
+
+@_typing.overload
+def KeyPair(name: Algorithm.BIKE) -> tuple[BIKESecretKey, BIKEPublicKey]: ...
+
+
+
+@_typing.overload
+def KeyPair(name: Algorithm.CLASSICMCELIECE) -> tuple[CLASSICMCELIECESecretKey, CLASSICMCELIECEPublicKey]: ...
+
+
+
+@_typing.overload
+def KeyPair(name: Algorithm.HQC) -> tuple[HQCSecretKey, HQCPublicKey]: ...
+
+
+
+@_typing.overload
+def KeyPair(name: Algorithm.KYBER) -> tuple[KYBERSecretKey, KYBERPublicKey]: ...
+
+
+
+@_typing.overload
+def KeyPair(name: Algorithm.MLKEM) -> tuple[MLKEMSecretKey, MLKEMPublicKey]: ...
+
+
+
+@_typing.overload
+def KeyPair(name: Algorithm.NTRUPRIME) -> tuple[NTRUPRIMESecretKey, NTRUPRIMEPublicKey]: ...
+
+
+
+@_typing.overload
+def KeyPair(name: Algorithm.FRODOKEM) -> tuple[FRODOKEMSecretKey, FRODOKEMPublicKey]: ...
+
+
+
+def KeyPair(name: Algorithms) -> tuple[SecretKey, PublicKey]:
+    algorithm = name
+    if isinstance(algorithm, Algorithm.BIKE):
+        secretkey, publickey = _internal.kemkeygen(algorithm.value) # type: ignore
+        return BIKESecretKey(algorithm, secretkey), BIKEPublicKey(algorithm, publickey) # type: ignore
+    elif isinstance(algorithm, Algorithm.CLASSICMCELIECE):
+        secretkey, publickey = _internal.kemkeygen(algorithm.value) # type: ignore
+        return CLASSICMCELIECESecretKey(algorithm, secretkey), CLASSICMCELIECEPublicKey(algorithm, publickey) # type: ignore
+    elif isinstance(algorithm, Algorithm.HQC):
+        secretkey, publickey = _internal.kemkeygen(algorithm.value) # type: ignore
+        return HQCSecretKey(algorithm, secretkey), HQCPublicKey(algorithm, publickey) # type: ignore
+    elif isinstance(algorithm, Algorithm.KYBER):
+        secretkey, publickey = _internal.kemkeygen(algorithm.value) # type: ignore
+        return KYBERSecretKey(algorithm, secretkey), KYBERPublicKey(algorithm, publickey) # type: ignore
+    elif isinstance(algorithm, Algorithm.MLKEM):
+        secretkey, publickey = _internal.kemkeygen(algorithm.value) # type: ignore
+        return MLKEMSecretKey(algorithm, secretkey), MLKEMPublicKey(algorithm, publickey) # type: ignore
+    elif isinstance(algorithm, Algorithm.NTRUPRIME):
+        secretkey, publickey = _internal.kemkeygen(algorithm.value) # type: ignore
+        return NTRUPRIMESecretKey(algorithm, secretkey), NTRUPRIMEPublicKey(algorithm, publickey) # type: ignore
+    elif isinstance(algorithm, Algorithm.FRODOKEM):
+        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.1.1.dist-info/METADATA

@@ -0,0 +1,66 @@
+Metadata-Version: 2.4
+Name: puantum
+Version: 1.1.1
+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.1.1.dist-info/RECORD

@@ -0,0 +1,12 @@
+puantum-1.1.1.dist-info/METADATA,sha256=fkR1pA0LXrj7i6HDAAq1vnQi2anznKaHLtx54kkSh0k,1524
+puantum-1.1.1.dist-info/WHEEL,sha256=AUbk9LW_pz5a6zxr9a09TpfZobAyvDuruoOj7fuVtLM,96
+puantum-1.1.1.dist-info/licenses/license.md,sha256=tQZYOMusRS38hVum5uAxSBrSxoQG9w0h6tkyE3RlPmw,1212
+puantum/__init__.py,sha256=DqzIK80d6ihVj9p2qBPJwBjM0V3kl6MRRjKowVB61Ak,8
+puantum/__internal__.cp313-win_amd64.pyd,sha256=cjhOPOrmTQyz-wQLWpjppo5BYtiAYF5joWpGf1rNUOQ,4341248
+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=A7oG_CDypKWhlKkjSRNRgyCrdrx2ekx3kTJaJED_Lmg,16609
+puantum/quantum/kem/__init__.py,sha256=U3TwWZ7eIYQgPeMXN2pfQvaqdWQimQTP-KDosfFvwk0,127
+puantum/quantum/kem/__internal__.py,sha256=iXegH9Zxh5M2L1ZK-7wLjRKehCruxK_W4X9OORGG8r0,19485
+puantum-1.1.1.dist-info/RECORD,,

puantum-1.1.1.dist-info/WHEEL

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

puantum-1.1.1.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/>