py2docfx 0.1.16rc2051518__py3-none-any.whl → 0.1.17__py3-none-any.whl

py2docfx/venv/venv1/Lib/site-packages/cryptography/hazmat/primitives/asymmetric/dsa.py

@@ -10,6 +10,7 @@ import typing
 from cryptography.hazmat.bindings._rust import openssl as rust_openssl
 from cryptography.hazmat.primitives import _serialization, hashes
 from cryptography.hazmat.primitives.asymmetric import utils as asym_utils
+from cryptography.utils import Buffer
 
 
 class DSAParameters(metaclass=abc.ABCMeta):
@@ -53,7 +54,7 @@ class DSAPrivateKey(metaclass=abc.ABCMeta):
     @abc.abstractmethod
     def sign(
         self,
-        data: bytes,
+        data: Buffer,
         algorithm: asym_utils.Prehashed | hashes.HashAlgorithm,
     ) -> bytes:
         """
@@ -77,6 +78,12 @@ class DSAPrivateKey(metaclass=abc.ABCMeta):
         Returns the key serialized as bytes.
         """
 
+    @abc.abstractmethod
+    def __copy__(self) -> DSAPrivateKey:
+        """
+        Returns a copy.
+        """
+
 
 DSAPrivateKeyWithSerialization = DSAPrivateKey
 DSAPrivateKey.register(rust_openssl.dsa.DSAPrivateKey)
@@ -115,8 +122,8 @@ class DSAPublicKey(metaclass=abc.ABCMeta):
     @abc.abstractmethod
     def verify(
         self,
-        signature: bytes,
-        data: bytes,
+        signature: Buffer,
+        data: Buffer,
         algorithm: asym_utils.Prehashed | hashes.HashAlgorithm,
     ) -> None:
         """
@@ -129,6 +136,12 @@ class DSAPublicKey(metaclass=abc.ABCMeta):
         Checks equality.
         """
 
+    @abc.abstractmethod
+    def __copy__(self) -> DSAPublicKey:
+        """
+        Returns a copy.
+        """
+
 
 DSAPublicKeyWithSerialization = DSAPublicKey
 DSAPublicKey.register(rust_openssl.dsa.DSAPublicKey)

py2docfx/venv/venv1/Lib/site-packages/cryptography/hazmat/primitives/asymmetric/ec.py

@@ -52,6 +52,13 @@ class EllipticCurve(metaclass=abc.ABCMeta):
         Bit size of a secret scalar for the curve.
         """
 
+    @property
+    @abc.abstractmethod
+    def group_order(self) -> int:
+        """
+        The order of the curve's group.
+        """
+
 
 class EllipticCurveSignatureAlgorithm(metaclass=abc.ABCMeta):
     @property
@@ -97,7 +104,7 @@ class EllipticCurvePrivateKey(metaclass=abc.ABCMeta):
     @abc.abstractmethod
     def sign(
         self,
-        data: bytes,
+        data: utils.Buffer,
         signature_algorithm: EllipticCurveSignatureAlgorithm,
     ) -> bytes:
         """
@@ -121,6 +128,12 @@ class EllipticCurvePrivateKey(metaclass=abc.ABCMeta):
         Returns the key serialized as bytes.
         """
 
+    @abc.abstractmethod
+    def __copy__(self) -> EllipticCurvePrivateKey:
+        """
+        Returns a copy.
+        """
+
 
 EllipticCurvePrivateKeyWithSerialization = EllipticCurvePrivateKey
 EllipticCurvePrivateKey.register(rust_openssl.ec.ECPrivateKey)
@@ -160,8 +173,8 @@ class EllipticCurvePublicKey(metaclass=abc.ABCMeta):
     @abc.abstractmethod
     def verify(
         self,
-        signature: bytes,
-        data: bytes,
+        signature: utils.Buffer,
+        data: utils.Buffer,
         signature_algorithm: EllipticCurveSignatureAlgorithm,
     ) -> None:
         """
@@ -188,6 +201,12 @@ class EllipticCurvePublicKey(metaclass=abc.ABCMeta):
         Checks equality.
         """
 
+    @abc.abstractmethod
+    def __copy__(self) -> EllipticCurvePublicKey:
+        """
+        Returns a copy.
+        """
+
 
 EllipticCurvePublicKeyWithSerialization = EllipticCurvePublicKey
 EllipticCurvePublicKey.register(rust_openssl.ec.ECPublicKey)
@@ -199,96 +218,121 @@ EllipticCurvePublicNumbers = rust_openssl.ec.EllipticCurvePublicNumbers
 class SECT571R1(EllipticCurve):
     name = "sect571r1"
     key_size = 570
+    group_order = 0x3FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFE661CE18FF55987308059B186823851EC7DD9CA1161DE93D5174D66E8382E9BB2FE84E47  # noqa: E501
 
 
 class SECT409R1(EllipticCurve):
     name = "sect409r1"
     key_size = 409
+    group_order = 0x10000000000000000000000000000000000000000000000000001E2AAD6A612F33307BE5FA47C3C9E052F838164CD37D9A21173  # noqa: E501
 
 
 class SECT283R1(EllipticCurve):
     name = "sect283r1"
     key_size = 283
+    group_order = 0x3FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFEF90399660FC938A90165B042A7CEFADB307  # noqa: E501
 
 
 class SECT233R1(EllipticCurve):
     name = "sect233r1"
     key_size = 233
+    group_order = 0x1000000000000000000000000000013E974E72F8A6922031D2603CFE0D7
 
 
 class SECT163R2(EllipticCurve):
     name = "sect163r2"
     key_size = 163
+    group_order = 0x40000000000000000000292FE77E70C12A4234C33
 
 
 class SECT571K1(EllipticCurve):
     name = "sect571k1"
     key_size = 571
+    group_order = 0x20000000000000000000000000000000000000000000000000000000000000000000000131850E1F19A63E4B391A8DB917F4138B630D84BE5D639381E91DEB45CFE778F637C1001  # noqa: E501
 
 
 class SECT409K1(EllipticCurve):
     name = "sect409k1"
     key_size = 409
+    group_order = 0x7FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFE5F83B2D4EA20400EC4557D5ED3E3E7CA5B4B5C83B8E01E5FCF  # noqa: E501
 
 
 class SECT283K1(EllipticCurve):
     name = "sect283k1"
     key_size = 283
+    group_order = 0x1FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFE9AE2ED07577265DFF7F94451E061E163C61  # noqa: E501
 
 
 class SECT233K1(EllipticCurve):
     name = "sect233k1"
     key_size = 233
+    group_order = 0x8000000000000000000000000000069D5BB915BCD46EFB1AD5F173ABDF
 
 
 class SECT163K1(EllipticCurve):
     name = "sect163k1"
     key_size = 163
+    group_order = 0x4000000000000000000020108A2E0CC0D99F8A5EF
 
 
 class SECP521R1(EllipticCurve):
     name = "secp521r1"
     key_size = 521
+    group_order = 0x1FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFA51868783BF2F966B7FCC0148F709A5D03BB5C9B8899C47AEBB6FB71E91386409  # noqa: E501
 
 
 class SECP384R1(EllipticCurve):
     name = "secp384r1"
     key_size = 384
+    group_order = 0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFC7634D81F4372DDF581A0DB248B0A77AECEC196ACCC52973  # noqa: E501
 
 
 class SECP256R1(EllipticCurve):
     name = "secp256r1"
     key_size = 256
+    group_order = (
+        0xFFFFFFFF00000000FFFFFFFFFFFFFFFFBCE6FAADA7179E84F3B9CAC2FC632551
+    )
 
 
 class SECP256K1(EllipticCurve):
     name = "secp256k1"
     key_size = 256
+    group_order = (
+        0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFEBAAEDCE6AF48A03BBFD25E8CD0364141
+    )
 
 
 class SECP224R1(EllipticCurve):
     name = "secp224r1"
     key_size = 224
+    group_order = 0xFFFFFFFFFFFFFFFFFFFFFFFFFFFF16A2E0B8F03E13DD29455C5C2A3D
 
 
 class SECP192R1(EllipticCurve):
     name = "secp192r1"
     key_size = 192
+    group_order = 0xFFFFFFFFFFFFFFFFFFFFFFFF99DEF836146BC9B1B4D22831
 
 
 class BrainpoolP256R1(EllipticCurve):
     name = "brainpoolP256r1"
     key_size = 256
+    group_order = (
+        0xA9FB57DBA1EEA9BC3E660A909D838D718C397AA3B561A6F7901E0E82974856A7
+    )
 
 
 class BrainpoolP384R1(EllipticCurve):
     name = "brainpoolP384r1"
     key_size = 384
+    group_order = 0x8CB91E82A3386D280F5D6F7E50E641DF152F7109ED5456B31F166E6CAC0425A7CF3AB6AF6B7FC3103B883202E9046565  # noqa: E501
 
 
 class BrainpoolP512R1(EllipticCurve):
     name = "brainpoolP512r1"
     key_size = 512
+    group_order = 0xAADD9DB8DBE9C48B3FD4E6AE33C9FC07CB308DB3B3C9D20ED6639CCA70330870553E5C414CA92619418661197FAC10471DB1D381085DDADDB58796829CA90069  # noqa: E501
 
 
 _CURVE_TYPES: dict[str, EllipticCurve] = {

py2docfx/venv/venv1/Lib/site-packages/cryptography/hazmat/primitives/asymmetric/ed25519.py

@@ -9,6 +9,7 @@ import abc
 from cryptography.exceptions import UnsupportedAlgorithm, _Reasons
 from cryptography.hazmat.bindings._rust import openssl as rust_openssl
 from cryptography.hazmat.primitives import _serialization
+from cryptography.utils import Buffer
 
 
 class Ed25519PublicKey(metaclass=abc.ABCMeta):
@@ -42,7 +43,7 @@ class Ed25519PublicKey(metaclass=abc.ABCMeta):
         """
 
     @abc.abstractmethod
-    def verify(self, signature: bytes, data: bytes) -> None:
+    def verify(self, signature: Buffer, data: Buffer) -> None:
         """
         Verify the signature.
         """
@@ -53,6 +54,12 @@ class Ed25519PublicKey(metaclass=abc.ABCMeta):
         Checks equality.
         """
 
+    @abc.abstractmethod
+    def __copy__(self) -> Ed25519PublicKey:
+        """
+        Returns a copy.
+        """
+
 
 Ed25519PublicKey.register(rust_openssl.ed25519.Ed25519PublicKey)
 
@@ -71,7 +78,7 @@ class Ed25519PrivateKey(metaclass=abc.ABCMeta):
         return rust_openssl.ed25519.generate_key()
 
     @classmethod
-    def from_private_bytes(cls, data: bytes) -> Ed25519PrivateKey:
+    def from_private_bytes(cls, data: Buffer) -> Ed25519PrivateKey:
         from cryptography.hazmat.backends.openssl.backend import backend
 
         if not backend.ed25519_supported():
@@ -107,10 +114,16 @@ class Ed25519PrivateKey(metaclass=abc.ABCMeta):
         """
 
     @abc.abstractmethod
-    def sign(self, data: bytes) -> bytes:
+    def sign(self, data: Buffer) -> bytes:
         """
         Signs the data.
         """
 
+    @abc.abstractmethod
+    def __copy__(self) -> Ed25519PrivateKey:
+        """
+        Returns a copy.
+        """
+
 
 Ed25519PrivateKey.register(rust_openssl.ed25519.Ed25519PrivateKey)

py2docfx/venv/venv1/Lib/site-packages/cryptography/hazmat/primitives/asymmetric/ed448.py

@@ -9,6 +9,7 @@ import abc
 from cryptography.exceptions import UnsupportedAlgorithm, _Reasons
 from cryptography.hazmat.bindings._rust import openssl as rust_openssl
 from cryptography.hazmat.primitives import _serialization
+from cryptography.utils import Buffer
 
 
 class Ed448PublicKey(metaclass=abc.ABCMeta):
@@ -42,7 +43,7 @@ class Ed448PublicKey(metaclass=abc.ABCMeta):
         """
 
     @abc.abstractmethod
-    def verify(self, signature: bytes, data: bytes) -> None:
+    def verify(self, signature: Buffer, data: Buffer) -> None:
         """
         Verify the signature.
         """
@@ -53,6 +54,12 @@ class Ed448PublicKey(metaclass=abc.ABCMeta):
         Checks equality.
         """
 
+    @abc.abstractmethod
+    def __copy__(self) -> Ed448PublicKey:
+        """
+        Returns a copy.
+        """
+
 
 if hasattr(rust_openssl, "ed448"):
     Ed448PublicKey.register(rust_openssl.ed448.Ed448PublicKey)
@@ -72,7 +79,7 @@ class Ed448PrivateKey(metaclass=abc.ABCMeta):
         return rust_openssl.ed448.generate_key()
 
     @classmethod
-    def from_private_bytes(cls, data: bytes) -> Ed448PrivateKey:
+    def from_private_bytes(cls, data: Buffer) -> Ed448PrivateKey:
         from cryptography.hazmat.backends.openssl.backend import backend
 
         if not backend.ed448_supported():
@@ -90,7 +97,7 @@ class Ed448PrivateKey(metaclass=abc.ABCMeta):
         """
 
     @abc.abstractmethod
-    def sign(self, data: bytes) -> bytes:
+    def sign(self, data: Buffer) -> bytes:
         """
         Signs the data.
         """
@@ -113,6 +120,12 @@ class Ed448PrivateKey(metaclass=abc.ABCMeta):
         Equivalent to private_bytes(Raw, Raw, NoEncryption()).
         """
 
+    @abc.abstractmethod
+    def __copy__(self) -> Ed448PrivateKey:
+        """
+        Returns a copy.
+        """
+
 
 if hasattr(rust_openssl, "x448"):
     Ed448PrivateKey.register(rust_openssl.ed448.Ed448PrivateKey)

py2docfx/venv/venv1/Lib/site-packages/cryptography/hazmat/primitives/asymmetric/rsa.py

@@ -63,6 +63,12 @@ class RSAPrivateKey(metaclass=abc.ABCMeta):
         Returns the key serialized as bytes.
         """
 
+    @abc.abstractmethod
+    def __copy__(self) -> RSAPrivateKey:
+        """
+        Returns a copy.
+        """
+
 
 RSAPrivateKeyWithSerialization = RSAPrivateKey
 RSAPrivateKey.register(rust_openssl.rsa.RSAPrivateKey)
@@ -127,6 +133,12 @@ class RSAPublicKey(metaclass=abc.ABCMeta):
         Checks equality.
         """
 
+    @abc.abstractmethod
+    def __copy__(self) -> RSAPublicKey:
+        """
+        Returns a copy.
+        """
+
 
 RSAPublicKeyWithSerialization = RSAPublicKey
 RSAPublicKey.register(rust_openssl.rsa.RSAPublicKey)
@@ -223,6 +235,8 @@ def rsa_recover_prime_factors(n: int, e: int, d: int) -> tuple[int, int]:
     no more than two factors. This function is adapted from code in PyCrypto.
     """
     # reject invalid values early
+    if d <= 1 or e <= 1:
+        raise ValueError("d, e can't be <= 1")
     if 17 != pow(17, e * d, n):
         raise ValueError("n, d, e don't match")
     # See 8.2.2(i) in Handbook of Applied Cryptography.

py2docfx/venv/venv1/Lib/site-packages/cryptography/hazmat/primitives/asymmetric/x25519.py

@@ -9,6 +9,7 @@ import abc
 from cryptography.exceptions import UnsupportedAlgorithm, _Reasons
 from cryptography.hazmat.bindings._rust import openssl as rust_openssl
 from cryptography.hazmat.primitives import _serialization
+from cryptography.utils import Buffer
 
 
 class X25519PublicKey(metaclass=abc.ABCMeta):
@@ -47,6 +48,12 @@ class X25519PublicKey(metaclass=abc.ABCMeta):
         Checks equality.
         """
 
+    @abc.abstractmethod
+    def __copy__(self) -> X25519PublicKey:
+        """
+        Returns a copy.
+        """
+
 
 X25519PublicKey.register(rust_openssl.x25519.X25519PublicKey)
 
@@ -64,7 +71,7 @@ class X25519PrivateKey(metaclass=abc.ABCMeta):
         return rust_openssl.x25519.generate_key()
 
     @classmethod
-    def from_private_bytes(cls, data: bytes) -> X25519PrivateKey:
+    def from_private_bytes(cls, data: Buffer) -> X25519PrivateKey:
         from cryptography.hazmat.backends.openssl.backend import backend
 
         if not backend.x25519_supported():
@@ -105,5 +112,11 @@ class X25519PrivateKey(metaclass=abc.ABCMeta):
         Performs a key exchange operation using the provided peer's public key.
         """
 
+    @abc.abstractmethod
+    def __copy__(self) -> X25519PrivateKey:
+        """
+        Returns a copy.
+        """
+
 
 X25519PrivateKey.register(rust_openssl.x25519.X25519PrivateKey)

py2docfx/venv/venv1/Lib/site-packages/cryptography/hazmat/primitives/asymmetric/x448.py

@@ -9,6 +9,7 @@ import abc
 from cryptography.exceptions import UnsupportedAlgorithm, _Reasons
 from cryptography.hazmat.bindings._rust import openssl as rust_openssl
 from cryptography.hazmat.primitives import _serialization
+from cryptography.utils import Buffer
 
 
 class X448PublicKey(metaclass=abc.ABCMeta):
@@ -47,6 +48,12 @@ class X448PublicKey(metaclass=abc.ABCMeta):
         Checks equality.
         """
 
+    @abc.abstractmethod
+    def __copy__(self) -> X448PublicKey:
+        """
+        Returns a copy.
+        """
+
 
 if hasattr(rust_openssl, "x448"):
     X448PublicKey.register(rust_openssl.x448.X448PublicKey)
@@ -66,7 +73,7 @@ class X448PrivateKey(metaclass=abc.ABCMeta):
         return rust_openssl.x448.generate_key()
 
     @classmethod
-    def from_private_bytes(cls, data: bytes) -> X448PrivateKey:
+    def from_private_bytes(cls, data: Buffer) -> X448PrivateKey:
         from cryptography.hazmat.backends.openssl.backend import backend
 
         if not backend.x448_supported():
@@ -107,6 +114,12 @@ class X448PrivateKey(metaclass=abc.ABCMeta):
         Performs a key exchange operation using the provided peer's public key.
         """
 
+    @abc.abstractmethod
+    def __copy__(self) -> X448PrivateKey:
+        """
+        Returns a copy.
+        """
+
 
 if hasattr(rust_openssl, "x448"):
     X448PrivateKey.register(rust_openssl.x448.X448PrivateKey)

py2docfx/venv/venv1/Lib/site-packages/cryptography/hazmat/primitives/ciphers/algorithms.py

@@ -36,7 +36,7 @@ class AES(BlockCipherAlgorithm):
     # 512 added to support AES-256-XTS, which uses 512-bit keys
     key_sizes = frozenset([128, 192, 256, 512])
 
-    def __init__(self, key: bytes):
+    def __init__(self, key: utils.Buffer):
         self.key = _verify_key_size(self, key)
 
     @property
@@ -50,7 +50,7 @@ class AES128(BlockCipherAlgorithm):
     key_sizes = frozenset([128])
     key_size = 128
 
-    def __init__(self, key: bytes):
+    def __init__(self, key: utils.Buffer):
         self.key = _verify_key_size(self, key)
 
 
@@ -60,7 +60,7 @@ class AES256(BlockCipherAlgorithm):
     key_sizes = frozenset([256])
     key_size = 256
 
-    def __init__(self, key: bytes):
+    def __init__(self, key: utils.Buffer):
         self.key = _verify_key_size(self, key)
 
 
@@ -69,7 +69,7 @@ class Camellia(BlockCipherAlgorithm):
     block_size = 128
     key_sizes = frozenset([128, 192, 256])
 
-    def __init__(self, key: bytes):
+    def __init__(self, key: utils.Buffer):
         self.key = _verify_key_size(self, key)
 
     @property
@@ -152,7 +152,7 @@ class ChaCha20(CipherAlgorithm):
     name = "ChaCha20"
     key_sizes = frozenset([256])
 
-    def __init__(self, key: bytes, nonce: bytes):
+    def __init__(self, key: utils.Buffer, nonce: utils.Buffer):
         self.key = _verify_key_size(self, key)
         utils._check_byteslike("nonce", nonce)
 
@@ -162,7 +162,7 @@ class ChaCha20(CipherAlgorithm):
         self._nonce = nonce
 
     @property
-    def nonce(self) -> bytes:
+    def nonce(self) -> utils.Buffer:
         return self._nonce
 
     @property

py2docfx/venv/venv1/Lib/site-packages/cryptography/hazmat/primitives/ciphers/base.py

@@ -10,18 +10,19 @@ import typing
 from cryptography.hazmat.bindings._rust import openssl as rust_openssl
 from cryptography.hazmat.primitives._cipheralgorithm import CipherAlgorithm
 from cryptography.hazmat.primitives.ciphers import modes
+from cryptography.utils import Buffer
 
 
 class CipherContext(metaclass=abc.ABCMeta):
     @abc.abstractmethod
-    def update(self, data: bytes) -> bytes:
+    def update(self, data: Buffer) -> bytes:
         """
         Processes the provided bytes through the cipher and returns the results
         as bytes.
         """
 
     @abc.abstractmethod
-    def update_into(self, data: bytes, buf: bytes) -> int:
+    def update_into(self, data: Buffer, buf: Buffer) -> int:
         """
         Processes the provided bytes and writes the resulting data into the
         provided buffer. Returns the number of bytes written.
@@ -44,7 +45,7 @@ class CipherContext(metaclass=abc.ABCMeta):
 
 class AEADCipherContext(CipherContext, metaclass=abc.ABCMeta):
     @abc.abstractmethod
-    def authenticate_additional_data(self, data: bytes) -> None:
+    def authenticate_additional_data(self, data: Buffer) -> None:
         """
         Authenticates the provided bytes.
         """
@@ -134,9 +135,9 @@ _CIPHER_TYPE = Cipher[
     typing.Union[
         modes.ModeWithNonce,
         modes.ModeWithTweak,
-        None,
         modes.ECB,
         modes.ModeWithInitializationVector,
+        None,
     ]
 ]