coinex-api 0.0.89__py3-none-any.whl → 0.0.110__py3-none-any.whl

coinex/ccxt/static_dependencies/bip/utils/crypto/aes_ecb.py

@@ -0,0 +1,152 @@
+# Copyright (c) 2021 Emanuele Bellocchia
+#
+# Permission is hereby granted, free of charge, to any person obtaining a copy
+# of this software and associated documentation files (the "Software"), to deal
+# in the Software without restriction, including without limitation the rights
+# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+# copies of the Software, and to permit persons to whom the Software is
+# furnished to do so, subject to the following conditions:
+#
+# The above copyright notice and this permission notice shall be included in
+# all copies or substantial portions of the Software.
+#
+# 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 OR COPYRIGHT HOLDERS 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.
+
+"""Module for AES-ECB encryption/decryption."""
+
+
+#
+# Imports
+#
+from typing import Any, Union
+
+from Crypto.Cipher import AES
+from Crypto.Util.Padding import pad, unpad
+
+from ..misc.algo import AlgoUtils
+
+
+#
+# Classes
+#
+
+class AesEcbEncrypter:
+    """
+    AES-ECB encrypter class.
+    It encrypts data using AES-ECB algorithm.
+    """
+
+    aes: Any
+    auto_pad: bool
+
+    # Constructor
+    def __init__(self,
+                 key: Union[str, bytes]) -> None:
+        """
+        Construct class.
+
+        Args:
+            key (str or bytes): AES key
+        """
+        self.aes = AES.new(AlgoUtils.Encode(key), AES.MODE_ECB)
+        self.auto_pad = True
+
+    def AutoPad(self,
+                value: bool) -> None:
+        """
+        Set the auto-pad flag.
+
+        Args:
+            value (bool): Flag value
+        """
+        self.auto_pad = value
+
+    def Encrypt(self,
+                data: Union[str, bytes]) -> bytes:
+        """
+        Encrypt data using AES-ECB algorithm.
+
+        Args:
+            data (str or bytes): Data to be encrypted
+
+        Returns:
+            bytes: Encrypted data
+        """
+        padded_data = self.Pad(data) if self.auto_pad else AlgoUtils.Encode(data)
+        return self.aes.encrypt(padded_data)
+
+    @staticmethod
+    def Pad(data: Union[str, bytes]) -> bytes:
+        """
+        Pad data using PKCS7 algorithm.
+
+        Args:
+            data (str or bytes): Data to be padded
+
+        Returns:
+            bytes: Padded data
+        """
+        return pad(AlgoUtils.Encode(data), AES.block_size)
+
+
+class AesEcbDecrypter:
+    """
+    AES-ECB decrypter class.
+    It decrypts data using AES-ECB algorithm.
+    """
+
+    aes: Any
+
+    def __init__(self,
+                 key: Union[str, bytes]) -> None:
+        """
+        Construct class.
+
+        Args:
+            key (str or bytes): AES key
+        """
+        self.aes = AES.new(AlgoUtils.Encode(key), AES.MODE_ECB)
+        self.auto_unpad = True
+
+    def AutoUnPad(self,
+                  value: bool) -> None:
+        """
+        Set the auto-unpad flag.
+
+        Args:
+            value (bool): Flag value
+        """
+        self.auto_unpad = value
+
+    def Decrypt(self,
+                data: bytes) -> bytes:
+        """
+        Decrypt data using AES-ECB algorithm.
+
+        Args:
+            data (bytes): Data to be decrypted
+
+        Returns:
+            bytes: Decrypted data
+        """
+        dec = self.aes.decrypt(data)
+        return self.UnPad(dec) if self.auto_unpad else dec
+
+    @staticmethod
+    def UnPad(data: bytes) -> bytes:
+        """
+        Unpad data using PKCS7 algorithm.
+
+        Args:
+            data (bytes): Data to be unpadded
+
+        Returns:
+            bytes: Unpadded data
+        """
+        return unpad(data, AES.block_size)

coinex/ccxt/static_dependencies/bip/utils/crypto/blake2.py

@@ -0,0 +1,191 @@
+# Copyright (c) 2022 Emanuele Bellocchia
+#
+# Permission is hereby granted, free of charge, to any person obtaining a copy
+# of this software and associated documentation files (the "Software"), to deal
+# in the Software without restriction, including without limitation the rights
+# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+# copies of the Software, and to permit persons to whom the Software is
+# furnished to do so, subject to the following conditions:
+#
+# The above copyright notice and this permission notice shall be included in
+# all copies or substantial portions of the Software.
+#
+# 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 OR COPYRIGHT HOLDERS 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.
+
+"""Module for BLAKE-2 algorithms."""
+
+# Imports
+import hashlib
+from abc import ABC, abstractmethod
+from typing import Union
+
+from ..misc import AlgoUtils
+
+
+class Blake2b:
+    """
+    BLAKE2b class.
+    It computes digests using BLAKE2b algorithm.
+    """
+
+    @staticmethod
+    def QuickDigest(data: Union[bytes, str],
+                    digest_size: int,
+                    key: Union[bytes, str] = b"",
+                    salt: Union[bytes, str] = b"") -> bytes:
+        """
+        Compute the digest (quick version).
+
+        Args:
+            data (str or bytes)           : Data
+            digest_size (int)             : Digest size
+            key ((str or bytes, optional) : Key (default: empty)
+            salt ((str or bytes, optional): Salt (default: empty)
+
+        Returns:
+            bytes: Computed digest
+        """
+        return hashlib.blake2b(AlgoUtils.Encode(data),
+                               digest_size=digest_size,
+                               key=AlgoUtils.Encode(key),
+                               salt=AlgoUtils.Encode(salt)).digest()
+
+
+class _Blake2bWithSpecificSize(ABC):
+    """Abstract class for Blake2b with specific digest size."""
+
+    @classmethod
+    def QuickDigest(cls,
+                    data: Union[bytes, str],
+                    key: Union[bytes, str] = b"",
+                    salt: Union[bytes, str] = b"") -> bytes:
+        """
+        Compute the digest (quick version).
+
+        Args:
+            data (str or bytes)          : Data
+            key (str or bytes, optional) : Key bytes (default: empty)
+            salt (str or bytes, optional): Salt bytes (default: empty)
+
+        Returns:
+            bytes: Computed digest
+        """
+        return Blake2b.QuickDigest(data, cls.DigestSize(), key, salt)
+
+    @staticmethod
+    @abstractmethod
+    def DigestSize() -> int:
+        """
+        Get the digest size in bytes.
+
+        Returns:
+            int: Digest size in bytes
+        """
+
+
+class Blake2b32(_Blake2bWithSpecificSize):
+    """
+    BLAKE2b-32 class.
+    It computes digests using BLAKE2b-32 algorithm.
+    """
+
+    @staticmethod
+    def DigestSize() -> int:
+        """
+        Get the digest size in bytes.
+
+        Returns:
+            int: Digest size in bytes
+        """
+        return 4
+
+
+class Blake2b40(_Blake2bWithSpecificSize):
+    """
+    BLAKE2b-40 class.
+    It computes digests using BLAKE2b-40 algorithm.
+    """
+
+    @staticmethod
+    def DigestSize() -> int:
+        """
+        Get the digest size in bytes.
+
+        Returns:
+            int: Digest size in bytes
+        """
+        return 5
+
+
+class Blake2b160(_Blake2bWithSpecificSize):
+    """
+    BLAKE2b-160 class.
+    It computes digests using BLAKE2b-160 algorithm.
+    """
+
+    @staticmethod
+    def DigestSize() -> int:
+        """
+        Get the digest size in bytes.
+
+        Returns:
+            int: Digest size in bytes
+        """
+        return 20
+
+
+class Blake2b224(_Blake2bWithSpecificSize):
+    """
+    BLAKE2b-224 class.
+    It computes digests using BLAKE2b-224 algorithm.
+    """
+
+    @staticmethod
+    def DigestSize() -> int:
+        """
+        Get the digest size in bytes.
+
+        Returns:
+            int: Digest size in bytes
+        """
+        return 28
+
+
+class Blake2b256(_Blake2bWithSpecificSize):
+    """
+    BLAKE2b-256 class.
+    It computes digests using BLAKE2b-256 algorithm.
+    """
+
+    @staticmethod
+    def DigestSize() -> int:
+        """
+        Get the digest size in bytes.
+
+        Returns:
+            int: Digest size in bytes
+        """
+        return 32
+
+
+class Blake2b512(_Blake2bWithSpecificSize):
+    """
+    BLAKE2b-512 class.
+    It computes digests using BLAKE2b-512 algorithm.
+    """
+
+    @staticmethod
+    def DigestSize() -> int:
+        """
+        Get the digest size in bytes.
+
+        Returns:
+            int: Digest size in bytes
+        """
+        return 64

coinex/ccxt/static_dependencies/bip/utils/crypto/chacha20_poly1305.py

@@ -0,0 +1,101 @@
+# Copyright (c) 2022 Emanuele Bellocchia
+#
+# Permission is hereby granted, free of charge, to any person obtaining a copy
+# of this software and associated documentation files (the "Software"), to deal
+# in the Software without restriction, including without limitation the rights
+# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+# copies of the Software, and to permit persons to whom the Software is
+# furnished to do so, subject to the following conditions:
+#
+# The above copyright notice and this permission notice shall be included in
+# all copies or substantial portions of the Software.
+#
+# 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 OR COPYRIGHT HOLDERS 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.
+
+"""Module for ChaCha20-Poly1305 algorithm."""
+
+# Imports
+from typing import Tuple, Union
+
+from Crypto.Cipher import ChaCha20_Poly1305
+
+from ..misc import AlgoUtils
+
+
+class ChaCha20Poly1305:
+    """
+    ChaCha20-Poly1305 class.
+    It decrypts/encrypts data using ChaCha20-Poly1305 algorithm.
+    """
+
+    @staticmethod
+    def Decrypt(key: Union[bytes, str],
+                nonce: Union[bytes, str],
+                assoc_data: Union[bytes, str],
+                cipher_text: Union[bytes, str],
+                tag: Union[bytes, str]) -> bytes:
+        """
+        Decrypt data.
+
+        Args:
+            key (str or bytes)       : Key
+            nonce (str or bytes)     : Nonce
+            assoc_data (str or bytes): Associated data
+            cipher_text (bytes)      : Cipher text
+            tag (bytes)              : Tag
+
+        Returns:
+            bytes: Decrypted data
+        """
+        cipher = ChaCha20_Poly1305.new(key=AlgoUtils.Encode(key),
+                                       nonce=AlgoUtils.Encode(nonce))
+        cipher.update(AlgoUtils.Encode(assoc_data))
+        return cipher.decrypt_and_verify(AlgoUtils.Encode(cipher_text), AlgoUtils.Encode(tag))
+
+    @staticmethod
+    def Encrypt(key: Union[bytes, str],
+                nonce: Union[bytes, str],
+                assoc_data: Union[bytes, str],
+                plain_text: Union[bytes, str]) -> Tuple[bytes, bytes]:
+        """
+        Encrypt data.
+
+        Args:
+            key (str or bytes)       : Key
+            nonce (str or bytes)     : Nonce
+            assoc_data (str or bytes): Associated data
+            plain_text (str or bytes): Plain text
+
+        Returns:
+            tuple[bytes, bytes]: Cipher text bytes (index 0) and tag bytes (index 1)
+        """
+        cipher = ChaCha20_Poly1305.new(key=AlgoUtils.Encode(key),
+                                       nonce=AlgoUtils.Encode(nonce))
+        cipher.update(AlgoUtils.Encode(assoc_data))
+        return cipher.encrypt_and_digest(AlgoUtils.Encode(plain_text))
+
+    @staticmethod
+    def KeySize() -> int:
+        """
+        Get the key size.
+
+        Returns:
+            int: Key size
+        """
+        return ChaCha20_Poly1305.key_size
+
+    @staticmethod
+    def TagSize() -> int:
+        """
+        Get the tag size.
+
+        Returns:
+            int: Tag size
+        """
+        return 16

coinex/ccxt/static_dependencies/bip/utils/crypto/hash160.py

@@ -0,0 +1,57 @@
+# Copyright (c) 2022 Emanuele Bellocchia
+#
+# Permission is hereby granted, free of charge, to any person obtaining a copy
+# of this software and associated documentation files (the "Software"), to deal
+# in the Software without restriction, including without limitation the rights
+# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+# copies of the Software, and to permit persons to whom the Software is
+# furnished to do so, subject to the following conditions:
+#
+# The above copyright notice and this permission notice shall be included in
+# all copies or substantial portions of the Software.
+#
+# 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 OR COPYRIGHT HOLDERS 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.
+
+"""Module for HASH160 algorithm."""
+
+# Imports
+from typing import Union
+
+from .ripemd import Ripemd160
+from .sha2 import Sha256
+
+
+class Hash160:
+    """
+    HASH160 class.
+    It computes digests using HASH160 algorithm.
+    """
+
+    @staticmethod
+    def QuickDigest(data: Union[bytes, str]) -> bytes:
+        """
+        Compute the digest (quick version).
+
+        Args:
+            data (str or bytes): Data
+
+        Returns:
+            bytes: Computed digest
+        """
+        return Ripemd160.QuickDigest(Sha256.QuickDigest(data))
+
+    @staticmethod
+    def DigestSize() -> int:
+        """
+        Get the digest size in bytes.
+
+        Returns:
+            int: Digest size in bytes
+        """
+        return Ripemd160.DigestSize()

coinex/ccxt/static_dependencies/bip/utils/crypto/hmac.py

@@ -0,0 +1,118 @@
+# Copyright (c) 2022 Emanuele Bellocchia
+#
+# Permission is hereby granted, free of charge, to any person obtaining a copy
+# of this software and associated documentation files (the "Software"), to deal
+# in the Software without restriction, including without limitation the rights
+# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+# copies of the Software, and to permit persons to whom the Software is
+# furnished to do so, subject to the following conditions:
+#
+# The above copyright notice and this permission notice shall be included in
+# all copies or substantial portions of the Software.
+#
+# 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 OR COPYRIGHT HOLDERS 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.
+
+"""Module for SHA-2 algorithms."""
+
+# Imports
+import hashlib
+import hmac
+from typing import Tuple, Union
+
+from ..misc import AlgoUtils
+
+
+HMAC_USE_DIGEST: bool = hasattr(hmac, "digest")
+
+
+class HmacSha256:
+    """
+    HMAC-SHA256 class.
+    It computes digests using HMAC-SHA256 algorithm.
+    """
+
+    @staticmethod
+    def QuickDigest(key: Union[bytes, str],
+                    data: Union[bytes, str]) -> bytes:
+        """
+        Compute the digest (quick version).
+
+        Args:
+            key (str or bytes) : Key
+            data (str or bytes): Data
+
+        Returns:
+            bytes: Computed digest
+        """
+        # Use digest if available
+        if HMAC_USE_DIGEST:
+            return hmac.digest(AlgoUtils.Encode(key), AlgoUtils.Encode(data), "sha256")
+        return hmac.new(AlgoUtils.Encode(key), AlgoUtils.Encode(data), hashlib.sha256).digest()
+
+    @staticmethod
+    def DigestSize() -> int:
+        """
+        Get the digest size in bytes.
+
+        Returns:
+            int: Digest size in bytes
+        """
+        return hashlib.sha256().digest_size
+
+
+class HmacSha512:
+    """
+    HMAC-SHA512 class.
+    It computes digests using HMAC-SHA512 algorithm.
+    """
+
+    @staticmethod
+    def QuickDigest(key: Union[bytes, str],
+                    data: Union[bytes, str]) -> bytes:
+        """
+        Compute the digest (quick version).
+
+        Args:
+            key (str or bytes) : Key
+            data (str or bytes): Data
+
+        Returns:
+            bytes: Computed digest
+        """
+
+        # Use digest if available
+        if HMAC_USE_DIGEST:
+            return hmac.digest(AlgoUtils.Encode(key), AlgoUtils.Encode(data), "sha512")
+        return hmac.new(AlgoUtils.Encode(key), AlgoUtils.Encode(data), hashlib.sha512).digest()
+
+    @staticmethod
+    def QuickDigestHalves(key: Union[bytes, str],
+                          data: Union[bytes, str]) -> Tuple[bytes, bytes]:
+        """
+        Compute the digest and return it split into two halves (quick version).
+
+        Args:
+            key (str or bytes) : Key
+            data (str or bytes): Data
+
+        Returns:
+            tuple[bytes, bytes]: Computed digest left part (index 0) and right part (index 1)
+        """
+        digest_bytes = HmacSha512.QuickDigest(key, data)
+        return digest_bytes[:HmacSha512.DigestSize() // 2], digest_bytes[HmacSha512.DigestSize() // 2:]
+
+    @staticmethod
+    def DigestSize() -> int:
+        """
+        Get the digest size in bytes.
+
+        Returns:
+            int: Digest size in bytes
+        """
+        return hashlib.sha512().digest_size

coinex/ccxt/static_dependencies/bip/utils/crypto/pbkdf2.py

@@ -0,0 +1,66 @@
+# Copyright (c) 2022 Emanuele Bellocchia
+#
+# Permission is hereby granted, free of charge, to any person obtaining a copy
+# of this software and associated documentation files (the "Software"), to deal
+# in the Software without restriction, including without limitation the rights
+# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+# copies of the Software, and to permit persons to whom the Software is
+# furnished to do so, subject to the following conditions:
+#
+# The above copyright notice and this permission notice shall be included in
+# all copies or substantial portions of the Software.
+#
+# 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 OR COPYRIGHT HOLDERS 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.
+
+"""Module for PBKDF2 algorithm."""
+
+# Imports
+import hashlib
+from typing import Optional, Union
+
+from Crypto.Hash import SHA512
+from Crypto.Protocol.KDF import PBKDF2
+
+from ..misc import AlgoUtils
+
+
+HASHLIB_USE_PBKDF2_SHA512: bool = hasattr(hashlib, "pbkdf2_hmac")   # For future changes
+
+
+class Pbkdf2HmacSha512:
+    """
+    PBKDF2 HMAC-SHA512 class.
+    It derives keys using PBKDF2 HMAC-SHA512 algorithm.
+    """
+
+    @staticmethod
+    def DeriveKey(password: Union[bytes, str],
+                  salt: Union[bytes, str],
+                  itr_num: int,
+                  dklen: Optional[int] = None) -> bytes:
+        """
+        Derive a key.
+
+        Args:
+            password (str or bytes): Password
+            salt (str or bytes)    : Salt
+            itr_num (int)          : Iteration number
+            dklen (int, optional)  : Length of the derived key (default: SHA-512 output length)
+
+        Returns:
+            bytes: Computed result
+        """
+        if HASHLIB_USE_PBKDF2_SHA512:
+            return hashlib.pbkdf2_hmac("sha512", AlgoUtils.Encode(password), AlgoUtils.Encode(salt), itr_num, dklen)
+        # Use Cryptodome if not implemented in hashlib
+        return PBKDF2(AlgoUtils.Encode(password),  # type: ignore [arg-type]
+                      AlgoUtils.Encode(salt),
+                      dklen or SHA512.digest_size,
+                      count=itr_num,
+                      hmac_hash_module=SHA512)