Add files using upload-large-folder tool

minigpt2/lib/python3.10/site-packages/Crypto/IO/PEM.py

@@ -0,0 +1,189 @@
+#
+#  Util/PEM.py : Privacy Enhanced Mail utilities
+#
+# ===================================================================
+#
+# Copyright (c) 2014, Legrandin <helderijs@gmail.com>
+# All rights reserved.
+#
+# Redistribution and use in source and binary forms, with or without
+# modification, are permitted provided that the following conditions
+# are met:
+#
+# 1. Redistributions of source code must retain the above copyright
+#    notice, this list of conditions and the following disclaimer.
+# 2. Redistributions in binary form must reproduce the above copyright
+#    notice, this list of conditions and the following disclaimer in
+#    the documentation and/or other materials provided with the
+#    distribution.
+#
+# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+# "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+# LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
+# FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
+# COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
+# INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
+# BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+# LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+# CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+# LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
+# ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+# POSSIBILITY OF SUCH DAMAGE.
+# ===================================================================
+
+__all__ = ['encode', 'decode']
+
+import re
+from binascii import a2b_base64, b2a_base64, hexlify, unhexlify
+
+from Crypto.Hash import MD5
+from Crypto.Util.Padding import pad, unpad
+from Crypto.Cipher import DES, DES3, AES
+from Crypto.Protocol.KDF import PBKDF1
+from Crypto.Random import get_random_bytes
+from Crypto.Util.py3compat import tobytes, tostr
+
+
+def encode(data, marker, passphrase=None, randfunc=None):
+    """Encode a piece of binary data into PEM format.
+
+    Args:
+      data (byte string):
+        The piece of binary data to encode.
+      marker (string):
+        The marker for the PEM block (e.g. "PUBLIC KEY").
+        Note that there is no official master list for all allowed markers.
+        Still, you can refer to the OpenSSL_ source code.
+      passphrase (byte string):
+        If given, the PEM block will be encrypted. The key is derived from
+        the passphrase.
+      randfunc (callable):
+        Random number generation function; it accepts an integer N and returns
+        a byte string of random data, N bytes long. If not given, a new one is
+        instantiated.
+
+    Returns:
+      The PEM block, as a string.
+
+    .. _OpenSSL: https://github.com/openssl/openssl/blob/master/include/openssl/pem.h
+    """
+
+    if randfunc is None:
+        randfunc = get_random_bytes
+
+    out = "-----BEGIN %s-----\n" % marker
+    if passphrase:
+        # We only support 3DES for encryption
+        salt = randfunc(8)
+        key = PBKDF1(passphrase, salt, 16, 1, MD5)
+        key += PBKDF1(key + passphrase, salt, 8, 1, MD5)
+        objenc = DES3.new(key, DES3.MODE_CBC, salt)
+        out += "Proc-Type: 4,ENCRYPTED\nDEK-Info: DES-EDE3-CBC,%s\n\n" %\
+            tostr(hexlify(salt).upper())
+        # Encrypt with PKCS#7 padding
+        data = objenc.encrypt(pad(data, objenc.block_size))
+    elif passphrase is not None:
+        raise ValueError("Empty password")
+
+    # Each BASE64 line can take up to 64 characters (=48 bytes of data)
+    # b2a_base64 adds a new line character!
+    chunks = [tostr(b2a_base64(data[i:i + 48]))
+              for i in range(0, len(data), 48)]
+    out += "".join(chunks)
+    out += "-----END %s-----" % marker
+    return out
+
+
+def _EVP_BytesToKey(data, salt, key_len):
+    d = [ b'' ]
+    m = (key_len + 15 ) // 16
+    for _ in range(m):
+        nd = MD5.new(d[-1] + data + salt).digest()
+        d.append(nd)
+    return b"".join(d)[:key_len]
+
+
+def decode(pem_data, passphrase=None):
+    """Decode a PEM block into binary.
+
+    Args:
+      pem_data (string):
+        The PEM block.
+      passphrase (byte string):
+        If given and the PEM block is encrypted,
+        the key will be derived from the passphrase.
+
+    Returns:
+      A tuple with the binary data, the marker string, and a boolean to
+      indicate if decryption was performed.
+
+    Raises:
+      ValueError: if decoding fails, if the PEM file is encrypted and no passphrase has
+                  been provided or if the passphrase is incorrect.
+    """
+
+    # Verify Pre-Encapsulation Boundary
+    r = re.compile(r"\s*-----BEGIN (.*)-----\s+")
+    m = r.match(pem_data)
+    if not m:
+        raise ValueError("Not a valid PEM pre boundary")
+    marker = m.group(1)
+
+    # Verify Post-Encapsulation Boundary
+    r = re.compile(r"-----END (.*)-----\s*$")
+    m = r.search(pem_data)
+    if not m or m.group(1) != marker:
+        raise ValueError("Not a valid PEM post boundary")
+
+    # Removes spaces and slit on lines
+    lines = pem_data.replace(" ", '').split()
+
+    # Decrypts, if necessary
+    if lines[1].startswith('Proc-Type:4,ENCRYPTED'):
+        if not passphrase:
+            raise ValueError("PEM is encrypted, but no passphrase available")
+        DEK = lines[2].split(':')
+        if len(DEK) != 2 or DEK[0] != 'DEK-Info':
+            raise ValueError("PEM encryption format not supported.")
+        algo, salt = DEK[1].split(',')
+        salt = unhexlify(tobytes(salt))
+
+        padding = True
+
+        if algo == "DES-CBC":
+            key = _EVP_BytesToKey(passphrase, salt, 8)
+            objdec = DES.new(key, DES.MODE_CBC, salt)
+        elif algo == "DES-EDE3-CBC":
+            key = _EVP_BytesToKey(passphrase, salt, 24)
+            objdec = DES3.new(key, DES3.MODE_CBC, salt)
+        elif algo == "AES-128-CBC":
+            key = _EVP_BytesToKey(passphrase, salt[:8], 16)
+            objdec = AES.new(key, AES.MODE_CBC, salt)
+        elif algo == "AES-192-CBC":
+            key = _EVP_BytesToKey(passphrase, salt[:8], 24)
+            objdec = AES.new(key, AES.MODE_CBC, salt)
+        elif algo == "AES-256-CBC":
+            key = _EVP_BytesToKey(passphrase, salt[:8], 32)
+            objdec = AES.new(key, AES.MODE_CBC, salt)
+        elif algo.lower() == "id-aes256-gcm":
+            key = _EVP_BytesToKey(passphrase, salt[:8], 32)
+            objdec = AES.new(key, AES.MODE_GCM, nonce=salt)
+            padding = False
+        else:
+            raise ValueError("Unsupport PEM encryption algorithm (%s)." % algo)
+        lines = lines[2:]
+    else:
+        objdec = None
+
+    # Decode body
+    data = a2b_base64(''.join(lines[1:-1]))
+    enc_flag = False
+    if objdec:
+        if padding:
+            data = unpad(objdec.decrypt(data), objdec.block_size)
+        else:
+            # There is no tag, so we don't use decrypt_and_verify
+            data = objdec.decrypt(data)
+        enc_flag = True
+
+    return (data, marker, enc_flag)

minigpt2/lib/python3.10/site-packages/Crypto/IO/PEM.pyi

@@ -0,0 +1,10 @@
+from typing import Tuple, Optional, Callable
+
+def encode(data: bytes,
+           marke: str,
+	   passphrase: Optional[bytes] = ...,
+	   randfunc: Optional[Callable[[int],bytes]] = ...) -> str: ...
+
+
+def decode(pem_data: str,
+           passphrase: Optional[bytes] = ...) -> Tuple[bytes, str, bool]: ...

minigpt2/lib/python3.10/site-packages/Crypto/IO/PKCS8.py

@@ -0,0 +1,226 @@
+#
+#  PublicKey/PKCS8.py : PKCS#8 functions
+#
+# ===================================================================
+#
+# Copyright (c) 2014, Legrandin <helderijs@gmail.com>
+# All rights reserved.
+#
+# Redistribution and use in source and binary forms, with or without
+# modification, are permitted provided that the following conditions
+# are met:
+#
+# 1. Redistributions of source code must retain the above copyright
+#    notice, this list of conditions and the following disclaimer.
+# 2. Redistributions in binary form must reproduce the above copyright
+#    notice, this list of conditions and the following disclaimer in
+#    the documentation and/or other materials provided with the
+#    distribution.
+#
+# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+# "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+# LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
+# FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
+# COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
+# INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
+# BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+# LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+# CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+# LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
+# ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+# POSSIBILITY OF SUCH DAMAGE.
+# ===================================================================
+
+
+from Crypto.Util.py3compat import *
+
+from Crypto.Util.asn1 import (
+            DerNull,
+            DerSequence,
+            DerObjectId,
+            DerOctetString,
+            )
+
+from Crypto.IO._PBES import PBES1, PBES2, PbesError
+
+
+__all__ = ['wrap', 'unwrap']
+
+
+def wrap(private_key, key_oid, passphrase=None, protection=None,
+         prot_params=None, key_params=DerNull(), randfunc=None):
+    """Wrap a private key into a PKCS#8 blob (clear or encrypted).
+
+    Args:
+
+      private_key (bytes):
+        The private key encoded in binary form. The actual encoding is
+        algorithm specific. In most cases, it is DER.
+
+      key_oid (string):
+        The object identifier (OID) of the private key to wrap.
+        It is a dotted string, like ``'1.2.840.113549.1.1.1'`` (for RSA keys)
+        or ``'1.2.840.10045.2.1'`` (for ECC keys).
+
+    Keyword Args:
+
+      passphrase (bytes or string):
+        The secret passphrase from which the wrapping key is derived.
+        Set it only if encryption is required.
+
+      protection (string):
+        The identifier of the algorithm to use for securely wrapping the key.
+        Refer to :ref:`the encryption parameters<enc_params>` .
+        The default value is ``'PBKDF2WithHMAC-SHA1AndDES-EDE3-CBC'``.
+
+      prot_params (dictionary):
+        Parameters for the key derivation function (KDF).
+        Refer to :ref:`the encryption parameters<enc_params>` .
+
+      key_params (DER object or None):
+        The ``parameters`` field to use in the ``AlgorithmIdentifier``
+        SEQUENCE. If ``None``, no ``parameters`` field will be added.
+        By default, the ASN.1 type ``NULL`` is used.
+
+      randfunc (callable):
+        Random number generation function; it should accept a single integer
+        N and return a string of random data, N bytes long.
+        If not specified, a new RNG will be instantiated
+        from :mod:`Crypto.Random`.
+
+    Returns:
+      bytes: The PKCS#8-wrapped private key (possibly encrypted).
+    """
+
+    #
+    #   PrivateKeyInfo ::= SEQUENCE {
+    #       version                 Version,
+    #       privateKeyAlgorithm     PrivateKeyAlgorithmIdentifier,
+    #       privateKey              PrivateKey,
+    #       attributes              [0]  IMPLICIT Attributes OPTIONAL
+    #   }
+    #
+    if key_params is None:
+        algorithm = DerSequence([DerObjectId(key_oid)])
+    else:
+        algorithm = DerSequence([DerObjectId(key_oid), key_params])
+
+    pk_info = DerSequence([
+                0,
+                algorithm,
+                DerOctetString(private_key)
+            ])
+    pk_info_der = pk_info.encode()
+
+    if passphrase is None:
+        return pk_info_der
+
+    if not passphrase:
+        raise ValueError("Empty passphrase")
+
+    # Encryption with PBES2
+    passphrase = tobytes(passphrase)
+    if protection is None:
+        protection = 'PBKDF2WithHMAC-SHA1AndDES-EDE3-CBC'
+    return PBES2.encrypt(pk_info_der, passphrase,
+                         protection, prot_params, randfunc)
+
+
+def unwrap(p8_private_key, passphrase=None):
+    """Unwrap a private key from a PKCS#8 blob (clear or encrypted).
+
+    Args:
+      p8_private_key (bytes):
+        The private key wrapped into a PKCS#8 container, DER encoded.
+
+    Keyword Args:
+      passphrase (byte string or string):
+        The passphrase to use to decrypt the blob (if it is encrypted).
+
+    Return:
+      A tuple containing
+
+       #. the algorithm identifier of the wrapped key (OID, dotted string)
+       #. the private key (bytes, DER encoded)
+       #. the associated parameters (bytes, DER encoded) or ``None``
+
+    Raises:
+      ValueError : if decoding fails
+    """
+
+    if passphrase is not None:
+        passphrase = tobytes(passphrase)
+
+        found = False
+        try:
+            p8_private_key = PBES1.decrypt(p8_private_key, passphrase)
+            found = True
+        except PbesError as e:
+            error_str = "PBES1[%s]" % str(e)
+        except ValueError:
+            error_str = "PBES1[Invalid]"
+
+        if not found:
+            try:
+                p8_private_key = PBES2.decrypt(p8_private_key, passphrase)
+                found = True
+            except PbesError as e:
+                error_str += ",PBES2[%s]" % str(e)
+            except ValueError:
+                error_str += ",PBES2[Invalid]"
+
+        if not found:
+            raise ValueError("Error decoding PKCS#8 (%s)" % error_str)
+
+    pk_info = DerSequence().decode(p8_private_key, nr_elements=(2, 3, 4, 5))
+    if len(pk_info) == 2 and not passphrase:
+        raise ValueError("Not a valid clear PKCS#8 structure "
+                         "(maybe it is encrypted?)")
+
+    # RFC5208, PKCS#8, version is v1(0)
+    #
+    #   PrivateKeyInfo ::= SEQUENCE {
+    #       version                 Version,
+    #       privateKeyAlgorithm     PrivateKeyAlgorithmIdentifier,
+    #       privateKey              PrivateKey,
+    #       attributes              [0]  IMPLICIT Attributes OPTIONAL
+    #   }
+    #
+    # RFC5915, Asymmetric Key Package, version is v2(1)
+    #
+    #   OneAsymmetricKey ::= SEQUENCE {
+    #       version                   Version,
+    #       privateKeyAlgorithm       PrivateKeyAlgorithmIdentifier,
+    #       privateKey                PrivateKey,
+    #       attributes            [0] Attributes OPTIONAL,
+    #       ...,
+    #       [[2: publicKey        [1] PublicKey OPTIONAL ]],
+    #       ...
+    #   }
+
+    if pk_info[0] == 0:
+        if len(pk_info) not in (3, 4):
+            raise ValueError("Not a valid PrivateKeyInfo SEQUENCE")
+    elif pk_info[0] == 1:
+        if len(pk_info) not in (3, 4, 5):
+            raise ValueError("Not a valid PrivateKeyInfo SEQUENCE")
+    else:
+        raise ValueError("Not a valid PrivateKeyInfo SEQUENCE")
+
+    algo = DerSequence().decode(pk_info[1], nr_elements=(1, 2))
+    algo_oid = DerObjectId().decode(algo[0]).value
+    if len(algo) == 1:
+        algo_params = None
+    else:
+        try:
+            DerNull().decode(algo[1])
+            algo_params = None
+        except:
+            algo_params = algo[1]
+
+    # PrivateKey ::= OCTET STRING
+    private_key = DerOctetString().decode(pk_info[2]).payload
+
+    # We ignore attributes and (for v2 only) publickey
+
+    return (algo_oid, private_key, algo_params)

minigpt2/lib/python3.10/site-packages/Crypto/IO/PKCS8.pyi

@@ -0,0 +1,17 @@
+from typing import Tuple, Optional, Union, Callable
+from typing_extensions import NotRequired
+
+from Crypto.Util.asn1 import DerObject
+from Crypto.IO._PBES import ProtParams
+
+
+def wrap(private_key: bytes,
+         key_oid: str,
+         passphrase: Union[bytes, str] = ...,
+         protection: str = ...,
+         prot_params: Optional[ProtParams] = ...,
+         key_params: Optional[DerObject] = ...,
+         randfunc: Optional[Callable[[int], str]] = ...) -> bytes: ...
+
+
+def unwrap(p8_private_key: bytes, passphrase: Optional[Union[bytes, str]] = ...) -> Tuple[str, bytes, Optional[bytes]]: ...

minigpt2/lib/python3.10/site-packages/Crypto/IO/_PBES.py

@@ -0,0 +1,546 @@
+#
+#  PublicKey/_PBES.py : Password-Based Encryption functions
+#
+# ===================================================================
+#
+# Copyright (c) 2014, Legrandin <helderijs@gmail.com>
+# All rights reserved.
+#
+# Redistribution and use in source and binary forms, with or without
+# modification, are permitted provided that the following conditions
+# are met:
+#
+# 1. Redistributions of source code must retain the above copyright
+#    notice, this list of conditions and the following disclaimer.
+# 2. Redistributions in binary form must reproduce the above copyright
+#    notice, this list of conditions and the following disclaimer in
+#    the documentation and/or other materials provided with the
+#    distribution.
+#
+# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+# "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+# LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
+# FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
+# COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
+# INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
+# BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+# LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+# CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+# LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
+# ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+# POSSIBILITY OF SUCH DAMAGE.
+# ===================================================================
+
+import re
+
+from Crypto import Hash
+from Crypto import Random
+from Crypto.Util.asn1 import (
+            DerSequence, DerOctetString,
+            DerObjectId, DerInteger,
+            )
+
+from Crypto.Cipher import AES
+from Crypto.Util.Padding import pad, unpad
+from Crypto.Protocol.KDF import PBKDF1, PBKDF2, scrypt
+
+_OID_PBE_WITH_MD5_AND_DES_CBC = "1.2.840.113549.1.5.3"
+_OID_PBE_WITH_MD5_AND_RC2_CBC = "1.2.840.113549.1.5.6"
+_OID_PBE_WITH_SHA1_AND_DES_CBC = "1.2.840.113549.1.5.10"
+_OID_PBE_WITH_SHA1_AND_RC2_CBC = "1.2.840.113549.1.5.11"
+
+_OID_PBES2 = "1.2.840.113549.1.5.13"
+
+_OID_PBKDF2 = "1.2.840.113549.1.5.12"
+_OID_SCRYPT = "1.3.6.1.4.1.11591.4.11"
+
+_OID_HMAC_SHA1 = "1.2.840.113549.2.7"
+
+_OID_DES_EDE3_CBC = "1.2.840.113549.3.7"
+_OID_AES128_CBC = "2.16.840.1.101.3.4.1.2"
+_OID_AES192_CBC = "2.16.840.1.101.3.4.1.22"
+_OID_AES256_CBC = "2.16.840.1.101.3.4.1.42"
+_OID_AES128_GCM = "2.16.840.1.101.3.4.1.6"
+_OID_AES192_GCM = "2.16.840.1.101.3.4.1.26"
+_OID_AES256_GCM = "2.16.840.1.101.3.4.1.46"
+
+class PbesError(ValueError):
+    pass
+
+# These are the ASN.1 definitions used by the PBES1/2 logic:
+#
+# EncryptedPrivateKeyInfo ::= SEQUENCE {
+#   encryptionAlgorithm  EncryptionAlgorithmIdentifier,
+#   encryptedData        EncryptedData
+# }
+#
+# EncryptionAlgorithmIdentifier ::= AlgorithmIdentifier
+#
+# EncryptedData ::= OCTET STRING
+#
+# AlgorithmIdentifier  ::=  SEQUENCE  {
+#       algorithm   OBJECT IDENTIFIER,
+#       parameters  ANY DEFINED BY algorithm OPTIONAL
+# }
+#
+# PBEParameter ::= SEQUENCE {
+#       salt OCTET STRING (SIZE(8)),
+#       iterationCount INTEGER
+# }
+#
+# PBES2-params ::= SEQUENCE {
+#       keyDerivationFunc AlgorithmIdentifier {{PBES2-KDFs}},
+#       encryptionScheme AlgorithmIdentifier {{PBES2-Encs}}
+# }
+#
+# PBKDF2-params ::= SEQUENCE {
+#   salt CHOICE {
+#       specified OCTET STRING,
+#       otherSource AlgorithmIdentifier {{PBKDF2-SaltSources}}
+#       },
+#   iterationCount INTEGER (1..MAX),
+#   keyLength INTEGER (1..MAX) OPTIONAL,
+#   prf AlgorithmIdentifier {{PBKDF2-PRFs}} DEFAULT algid-hmacWithSHA1
+#   }
+#
+#   PBKDF2-PRFs ALGORITHM-IDENTIFIER ::= {
+#        {NULL IDENTIFIED BY id-hmacWithSHA1},
+#        {NULL IDENTIFIED BY id-hmacWithSHA224},
+#        {NULL IDENTIFIED BY id-hmacWithSHA256},
+#        {NULL IDENTIFIED BY id-hmacWithSHA384},
+#        {NULL IDENTIFIED BY id-hmacWithSHA512},
+#        {NULL IDENTIFIED BY id-hmacWithSHA512-224},
+#        {NULL IDENTIFIED BY id-hmacWithSHA512-256},
+#        ...
+# }
+# scrypt-params ::= SEQUENCE {
+#       salt OCTET STRING,
+#       costParameter INTEGER (1..MAX),
+#       blockSize INTEGER (1..MAX),
+#       parallelizationParameter INTEGER (1..MAX),
+#       keyLength INTEGER (1..MAX) OPTIONAL
+#   }
+
+
+class PBES1(object):
+    """Deprecated encryption scheme with password-based key derivation
+    (originally defined in PKCS#5 v1.5, but still present in `v2.0`__).
+
+    .. __: http://www.ietf.org/rfc/rfc2898.txt
+    """
+
+    @staticmethod
+    def decrypt(data, passphrase):
+        """Decrypt a piece of data using a passphrase and *PBES1*.
+
+        The algorithm to use is automatically detected.
+
+        :Parameters:
+          data : byte string
+            The piece of data to decrypt.
+          passphrase : byte string
+            The passphrase to use for decrypting the data.
+        :Returns:
+          The decrypted data, as a binary string.
+        """
+
+        enc_private_key_info = DerSequence().decode(data)
+        encrypted_algorithm = DerSequence().decode(enc_private_key_info[0])
+        encrypted_data = DerOctetString().decode(enc_private_key_info[1]).payload
+
+        pbe_oid = DerObjectId().decode(encrypted_algorithm[0]).value
+        cipher_params = {}
+        if pbe_oid == _OID_PBE_WITH_MD5_AND_DES_CBC:
+            # PBE_MD5_DES_CBC
+            from Crypto.Hash import MD5
+            from Crypto.Cipher import DES
+            hashmod = MD5
+            module = DES
+        elif pbe_oid == _OID_PBE_WITH_MD5_AND_RC2_CBC:
+            # PBE_MD5_RC2_CBC
+            from Crypto.Hash import MD5
+            from Crypto.Cipher import ARC2
+            hashmod = MD5
+            module = ARC2
+            cipher_params['effective_keylen'] = 64
+        elif pbe_oid == _OID_PBE_WITH_SHA1_AND_DES_CBC:
+            # PBE_SHA1_DES_CBC
+            from Crypto.Hash import SHA1
+            from Crypto.Cipher import DES
+            hashmod = SHA1
+            module = DES
+        elif pbe_oid == _OID_PBE_WITH_SHA1_AND_RC2_CBC:
+            # PBE_SHA1_RC2_CBC
+            from Crypto.Hash import SHA1
+            from Crypto.Cipher import ARC2
+            hashmod = SHA1
+            module = ARC2
+            cipher_params['effective_keylen'] = 64
+        else:
+            raise PbesError("Unknown OID for PBES1")
+
+        pbe_params = DerSequence().decode(encrypted_algorithm[1], nr_elements=2)
+        salt = DerOctetString().decode(pbe_params[0]).payload
+        iterations = pbe_params[1]
+
+        key_iv = PBKDF1(passphrase, salt, 16, iterations, hashmod)
+        key, iv = key_iv[:8], key_iv[8:]
+
+        cipher = module.new(key, module.MODE_CBC, iv, **cipher_params)
+        pt = cipher.decrypt(encrypted_data)
+        return unpad(pt, cipher.block_size)
+
+
+class PBES2(object):
+    """Encryption scheme with password-based key derivation
+    (defined in `PKCS#5 v2.0`__).
+
+    .. __: http://www.ietf.org/rfc/rfc2898.txt."""
+
+    @staticmethod
+    def encrypt(data, passphrase, protection, prot_params=None, randfunc=None):
+        """Encrypt a piece of data using a passphrase and *PBES2*.
+
+        :Parameters:
+          data : byte string
+            The piece of data to encrypt.
+          passphrase : byte string
+            The passphrase to use for encrypting the data.
+          protection : string
+            The identifier of the encryption algorithm to use.
+            The default value is '``PBKDF2WithHMAC-SHA1AndDES-EDE3-CBC``'.
+          prot_params : dictionary
+            Parameters of the protection algorithm.
+
+            +------------------+-----------------------------------------------+
+            | Key              | Description                                   |
+            +==================+===============================================+
+            | iteration_count  | The KDF algorithm is repeated several times to|
+            |                  | slow down brute force attacks on passwords    |
+            |                  | (called *N* or CPU/memory cost in scrypt).    |
+            |                  |                                               |
+            |                  | The default value for PBKDF2 is 1 000.        |
+            |                  | The default value for scrypt is 16 384.       |
+            +------------------+-----------------------------------------------+
+            | salt_size        | Salt is used to thwart dictionary and rainbow |
+            |                  | attacks on passwords. The default value is 8  |
+            |                  | bytes.                                        |
+            +------------------+-----------------------------------------------+
+            | block_size       | *(scrypt only)* Memory-cost (r). The default  |
+            |                  | value is 8.                                   |
+            +------------------+-----------------------------------------------+
+            | parallelization  | *(scrypt only)* CPU-cost (p). The default     |
+            |                  | value is 1.                                   |
+            +------------------+-----------------------------------------------+
+
+
+          randfunc : callable
+            Random number generation function; it should accept
+            a single integer N and return a string of random data,
+            N bytes long. If not specified, a new RNG will be
+            instantiated from ``Crypto.Random``.
+
+        :Returns:
+          The encrypted data, as a binary string.
+        """
+
+        if prot_params is None:
+            prot_params = {}
+
+        if randfunc is None:
+            randfunc = Random.new().read
+
+        pattern = re.compile(r'^(PBKDF2WithHMAC-([0-9A-Z-]+)|scrypt)And([0-9A-Z-]+)$')
+        res = pattern.match(protection)
+        if res is None:
+            raise ValueError("Unknown protection %s" % protection)
+
+        if protection.startswith("PBKDF"):
+            pbkdf = "pbkdf2"
+            pbkdf2_hmac_algo = res.group(2)
+            enc_algo = res.group(3)
+        else:
+            pbkdf = "scrypt"
+            enc_algo = res.group(3)
+
+        aead = False
+        if enc_algo == 'DES-EDE3-CBC':
+            from Crypto.Cipher import DES3
+            key_size = 24
+            module = DES3
+            cipher_mode = DES3.MODE_CBC
+            enc_oid = _OID_DES_EDE3_CBC
+            enc_param = {'iv': randfunc(8)}
+        elif enc_algo == 'AES128-CBC':
+            key_size = 16
+            module = AES
+            cipher_mode = AES.MODE_CBC
+            enc_oid = _OID_AES128_CBC
+            enc_param = {'iv': randfunc(16)}
+        elif enc_algo == 'AES192-CBC':
+            key_size = 24
+            module = AES
+            cipher_mode = AES.MODE_CBC
+            enc_oid = _OID_AES192_CBC
+            enc_param = {'iv': randfunc(16)}
+        elif enc_algo == 'AES256-CBC':
+            key_size = 32
+            module = AES
+            cipher_mode = AES.MODE_CBC
+            enc_oid = _OID_AES256_CBC
+            enc_param = {'iv': randfunc(16)}
+        elif enc_algo == 'AES128-GCM':
+            key_size = 16
+            module = AES
+            cipher_mode = AES.MODE_GCM
+            enc_oid = _OID_AES128_GCM
+            enc_param = {'nonce': randfunc(12)}
+            aead = True
+        elif enc_algo == 'AES192-GCM':
+            key_size = 24
+            module = AES
+            cipher_mode = AES.MODE_GCM
+            enc_oid = _OID_AES192_GCM
+            enc_param = {'nonce': randfunc(12)}
+            aead = True
+        elif enc_algo == 'AES256-GCM':
+            key_size = 32
+            module = AES
+            cipher_mode = AES.MODE_GCM
+            enc_oid = _OID_AES256_GCM
+            enc_param = {'nonce': randfunc(12)}
+            aead = True
+        else:
+            raise ValueError("Unknown encryption mode '%s'" % enc_algo)
+
+        iv_nonce = list(enc_param.values())[0]
+        salt = randfunc(prot_params.get("salt_size", 8))
+
+        # Derive key from password
+        if pbkdf == 'pbkdf2':
+
+            count = prot_params.get("iteration_count", 1000)
+            digestmod = Hash.new(pbkdf2_hmac_algo)
+
+            key = PBKDF2(passphrase,
+                         salt,
+                         key_size,
+                         count,
+                         hmac_hash_module=digestmod)
+
+            pbkdf2_params = DerSequence([
+                                DerOctetString(salt),
+                                DerInteger(count)
+                            ])
+
+            if pbkdf2_hmac_algo != 'SHA1':
+                try:
+                    hmac_oid = Hash.HMAC.new(b'', digestmod=digestmod).oid
+                except KeyError:
+                    raise ValueError("No OID for HMAC hash algorithm")
+                pbkdf2_params.append(DerSequence([DerObjectId(hmac_oid)]))
+
+            kdf_info = DerSequence([
+                    DerObjectId(_OID_PBKDF2),   # PBKDF2
+                    pbkdf2_params
+            ])
+
+        elif pbkdf == 'scrypt':
+
+            count = prot_params.get("iteration_count", 16384)
+            scrypt_r = prot_params.get('block_size', 8)
+            scrypt_p = prot_params.get('parallelization', 1)
+            key = scrypt(passphrase, salt, key_size,
+                         count, scrypt_r, scrypt_p)
+            kdf_info = DerSequence([
+                    DerObjectId(_OID_SCRYPT),  # scrypt
+                    DerSequence([
+                        DerOctetString(salt),
+                        DerInteger(count),
+                        DerInteger(scrypt_r),
+                        DerInteger(scrypt_p)
+                    ])
+            ])
+
+        else:
+            raise ValueError("Unknown KDF " + res.group(1))
+
+        # Create cipher and use it
+        cipher = module.new(key, cipher_mode, **enc_param)
+        if aead:
+            ct, tag = cipher.encrypt_and_digest(data)
+            encrypted_data = ct + tag
+        else:
+            encrypted_data = cipher.encrypt(pad(data, cipher.block_size))
+        enc_info = DerSequence([
+                DerObjectId(enc_oid),
+                DerOctetString(iv_nonce)
+        ])
+
+        # Result
+        enc_private_key_info = DerSequence([
+            # encryptionAlgorithm
+            DerSequence([
+                DerObjectId(_OID_PBES2),
+                DerSequence([
+                    kdf_info,
+                    enc_info
+                ]),
+            ]),
+            DerOctetString(encrypted_data)
+        ])
+        return enc_private_key_info.encode()
+
+    @staticmethod
+    def decrypt(data, passphrase):
+        """Decrypt a piece of data using a passphrase and *PBES2*.
+
+        The algorithm to use is automatically detected.
+
+        :Parameters:
+          data : byte string
+            The piece of data to decrypt.
+          passphrase : byte string
+            The passphrase to use for decrypting the data.
+        :Returns:
+          The decrypted data, as a binary string.
+        """
+
+        enc_private_key_info = DerSequence().decode(data, nr_elements=2)
+        enc_algo = DerSequence().decode(enc_private_key_info[0])
+        encrypted_data = DerOctetString().decode(enc_private_key_info[1]).payload
+
+        pbe_oid = DerObjectId().decode(enc_algo[0]).value
+        if pbe_oid != _OID_PBES2:
+            raise PbesError("Not a PBES2 object")
+
+        pbes2_params = DerSequence().decode(enc_algo[1], nr_elements=2)
+
+        # Key Derivation Function selection
+        kdf_info = DerSequence().decode(pbes2_params[0], nr_elements=2)
+        kdf_oid = DerObjectId().decode(kdf_info[0]).value
+
+        kdf_key_length = None
+
+        # We only support PBKDF2 or scrypt
+        if kdf_oid == _OID_PBKDF2:
+
+            pbkdf2_params = DerSequence().decode(kdf_info[1], nr_elements=(2, 3, 4))
+            salt = DerOctetString().decode(pbkdf2_params[0]).payload
+            iteration_count = pbkdf2_params[1]
+
+            left = len(pbkdf2_params) - 2
+            idx = 2
+
+            if left > 0:
+                try:
+                    # Check if it's an INTEGER
+                    kdf_key_length = pbkdf2_params[idx] - 0
+                    left -= 1
+                    idx += 1
+                except TypeError:
+                    # keyLength is not present
+                    pass
+
+            # Default is HMAC-SHA1
+            pbkdf2_prf_oid = _OID_HMAC_SHA1
+            if left > 0:
+                pbkdf2_prf_algo_id = DerSequence().decode(pbkdf2_params[idx])
+                pbkdf2_prf_oid = DerObjectId().decode(pbkdf2_prf_algo_id[0]).value
+
+        elif kdf_oid == _OID_SCRYPT:
+
+            scrypt_params = DerSequence().decode(kdf_info[1], nr_elements=(4, 5))
+            salt = DerOctetString().decode(scrypt_params[0]).payload
+            iteration_count, scrypt_r, scrypt_p = [scrypt_params[x]
+                                                   for x in (1, 2, 3)]
+            if len(scrypt_params) > 4:
+                kdf_key_length = scrypt_params[4]
+            else:
+                kdf_key_length = None
+        else:
+            raise PbesError("Unsupported PBES2 KDF")
+
+        # Cipher selection
+        enc_info = DerSequence().decode(pbes2_params[1])
+        enc_oid = DerObjectId().decode(enc_info[0]).value
+
+        aead = False
+        if enc_oid == _OID_DES_EDE3_CBC:
+            # DES_EDE3_CBC
+            from Crypto.Cipher import DES3
+            module = DES3
+            cipher_mode = DES3.MODE_CBC
+            key_size = 24
+            cipher_param = 'iv'
+        elif enc_oid == _OID_AES128_CBC:
+            module = AES
+            cipher_mode = AES.MODE_CBC
+            key_size = 16
+            cipher_param = 'iv'
+        elif enc_oid == _OID_AES192_CBC:
+            module = AES
+            cipher_mode = AES.MODE_CBC
+            key_size = 24
+            cipher_param = 'iv'
+        elif enc_oid == _OID_AES256_CBC:
+            module = AES
+            cipher_mode = AES.MODE_CBC
+            key_size = 32
+            cipher_param = 'iv'
+        elif enc_oid == _OID_AES128_GCM:
+            module = AES
+            cipher_mode = AES.MODE_GCM
+            key_size = 16
+            cipher_param = 'nonce'
+            aead = True
+        elif enc_oid == _OID_AES192_GCM:
+            module = AES
+            cipher_mode = AES.MODE_GCM
+            key_size = 24
+            cipher_param = 'nonce'
+            aead = True
+        elif enc_oid == _OID_AES256_GCM:
+            module = AES
+            cipher_mode = AES.MODE_GCM
+            key_size = 32
+            cipher_param = 'nonce'
+            aead = True
+        else:
+            raise PbesError("Unsupported PBES2 cipher " + enc_algo)
+
+        if kdf_key_length and kdf_key_length != key_size:
+            raise PbesError("Mismatch between PBES2 KDF parameters"
+                            " and selected cipher")
+
+        iv_nonce = DerOctetString().decode(enc_info[1]).payload
+
+        # Create cipher
+        if kdf_oid == _OID_PBKDF2:
+
+            try:
+                hmac_hash_module_oid = Hash.HMAC._hmac2hash_oid[pbkdf2_prf_oid]
+            except KeyError:
+                raise PbesError("Unsupported HMAC %s" % pbkdf2_prf_oid)
+            hmac_hash_module = Hash.new(hmac_hash_module_oid)
+
+            key = PBKDF2(passphrase, salt, key_size, iteration_count,
+                         hmac_hash_module=hmac_hash_module)
+        else:
+            key = scrypt(passphrase, salt, key_size, iteration_count,
+                         scrypt_r, scrypt_p)
+        cipher = module.new(key, cipher_mode, **{cipher_param:iv_nonce})
+
+        # Decrypt data
+        if len(encrypted_data) < cipher.block_size:
+            raise ValueError("Too little data to decrypt")
+
+        if aead:
+            tag_len = cipher.block_size
+            pt = cipher.decrypt_and_verify(encrypted_data[:-tag_len],
+                                           encrypted_data[-tag_len:])
+        else:
+            pt_padded = cipher.decrypt(encrypted_data)
+            pt = unpad(pt_padded, cipher.block_size)
+
+        return pt

minigpt2/lib/python3.10/site-packages/Crypto/IO/_PBES.pyi

@@ -0,0 +1,26 @@
+from typing import Optional, Callable, TypedDict
+from typing_extensions import NotRequired
+
+class PbesError(ValueError):
+    ...
+
+class PBES1(object):
+    @staticmethod
+    def decrypt(data: bytes, passphrase: bytes) -> bytes: ...
+
+class ProtParams(TypedDict):
+    iteration_count: NotRequired[int]
+    salt_size: NotRequired[int]
+    block_size: NotRequired[int]
+    parallelization: NotRequired[int]
+
+class PBES2(object):
+    @staticmethod
+    def encrypt(data: bytes,
+                passphrase: bytes,
+                protection: str,
+                prot_params: Optional[ProtParams] = ...,
+                randfunc: Optional[Callable[[int],bytes]] = ...) -> bytes: ...
+
+    @staticmethod
+    def decrypt(data:bytes, passphrase: bytes) -> bytes: ...

minigpt2/lib/python3.10/site-packages/Crypto/IO/__init__.py

@@ -0,0 +1,31 @@
+# ===================================================================
+#
+# Copyright (c) 2014, Legrandin <helderijs@gmail.com>
+# All rights reserved.
+#
+# Redistribution and use in source and binary forms, with or without
+# modification, are permitted provided that the following conditions
+# are met:
+#
+# 1. Redistributions of source code must retain the above copyright
+#    notice, this list of conditions and the following disclaimer.
+# 2. Redistributions in binary form must reproduce the above copyright
+#    notice, this list of conditions and the following disclaimer in
+#    the documentation and/or other materials provided with the
+#    distribution.
+#
+# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+# "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+# LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
+# FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
+# COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
+# INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
+# BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+# LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+# CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+# LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
+# ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+# POSSIBILITY OF SUCH DAMAGE.
+# ===================================================================
+
+__all__ = ['PEM', 'PKCS8']

minigpt2/lib/python3.10/site-packages/Crypto/Protocol/DH.py

@@ -0,0 +1,192 @@
+from Crypto.Util.number import long_to_bytes
+from Crypto.PublicKey.ECC import (EccKey,
+                                  construct,
+                                  _import_curve25519_public_key,
+                                  _import_curve448_public_key)
+
+
+def _compute_ecdh(key_priv, key_pub):
+    pointP = key_pub.pointQ * key_priv.d
+    if pointP.is_point_at_infinity():
+         raise ValueError("Invalid ECDH point")
+
+    if key_priv.curve == "Curve25519":
+        z = bytearray(pointP.x.to_bytes(32, byteorder='little'))
+    elif key_priv.curve == "Curve448":
+        z = bytearray(pointP.x.to_bytes(56, byteorder='little'))
+    else:
+        # See Section 5.7.1.2 in NIST SP 800-56Ar3
+        z = long_to_bytes(pointP.x, pointP.size_in_bytes())
+    return z
+
+
+def import_x25519_public_key(encoded):
+    """Create a new X25519 public key object,
+    starting from the key encoded as raw ``bytes``,
+    in the format described in RFC7748.
+
+    Args:
+      encoded (bytes):
+        The x25519 public key to import.
+        It must be 32 bytes.
+
+    Returns:
+      :class:`Crypto.PublicKey.EccKey` : a new ECC key object.
+
+    Raises:
+      ValueError: when the given key cannot be parsed.
+    """
+
+    x = _import_curve25519_public_key(encoded)
+    return construct(curve='Curve25519', point_x=x)
+
+
+def import_x25519_private_key(encoded):
+    """Create a new X25519 private key object,
+    starting from the key encoded as raw ``bytes``,
+    in the format described in RFC7748.
+
+    Args:
+      encoded (bytes):
+        The X25519 private key to import.
+        It must be 32 bytes.
+
+    Returns:
+      :class:`Crypto.PublicKey.EccKey` : a new ECC key object.
+
+    Raises:
+      ValueError: when the given key cannot be parsed.
+    """
+
+    return construct(seed=encoded, curve="Curve25519")
+
+
+def import_x448_public_key(encoded):
+    """Create a new X448 public key object,
+    starting from the key encoded as raw ``bytes``,
+    in the format described in RFC7748.
+
+    Args:
+      encoded (bytes):
+        The x448 public key to import.
+        It must be 56 bytes.
+
+    Returns:
+      :class:`Crypto.PublicKey.EccKey` : a new ECC key object.
+
+    Raises:
+      ValueError: when the given key cannot be parsed.
+    """
+
+    x = _import_curve448_public_key(encoded)
+    return construct(curve='Curve448', point_x=x)
+
+
+def import_x448_private_key(encoded):
+    """Create a new X448 private key object,
+    starting from the key encoded as raw ``bytes``,
+    in the format described in RFC7748.
+
+    Args:
+      encoded (bytes):
+        The X448 private key to import.
+        It must be 56 bytes.
+
+    Returns:
+      :class:`Crypto.PublicKey.EccKey` : a new ECC key object.
+
+    Raises:
+      ValueError: when the given key cannot be parsed.
+    """
+
+    return construct(seed=encoded, curve="Curve448")
+
+
+def key_agreement(**kwargs):
+    """Perform a Diffie-Hellman key agreement.
+
+    Keywords:
+      kdf (callable):
+        A key derivation function that accepts ``bytes`` as input and returns
+        ``bytes``.
+      static_priv (EccKey):
+        The local static private key. Optional.
+      static_pub (EccKey):
+        The static public key that belongs to the peer. Optional.
+      eph_priv (EccKey):
+        The local ephemeral private key, generated for this session. Optional.
+      eph_pub (EccKey):
+        The ephemeral public key, received from the peer for this session. Optional.
+
+    At least two keys must be passed, of which one is a private key and one
+    a public key.
+
+    Returns (bytes):
+      The derived secret key material.
+    """
+
+    static_priv = kwargs.get('static_priv', None)
+    static_pub = kwargs.get('static_pub', None)
+    eph_priv = kwargs.get('eph_priv', None)
+    eph_pub = kwargs.get('eph_pub', None)
+    kdf = kwargs.get('kdf', None)
+
+    if kdf is None:
+        raise ValueError("'kdf' is mandatory")
+
+    count_priv = 0
+    count_pub = 0
+    curve = None
+
+    def check_curve(curve, key, name, private):
+        if not isinstance(key, EccKey):
+            raise TypeError("'%s' must be an ECC key" % name)
+        if private and not key.has_private():
+            raise TypeError("'%s' must be a private ECC key" % name)
+        if curve is None:
+            curve = key.curve
+        elif curve != key.curve:
+            raise TypeError("'%s' is defined on an incompatible curve" % name)
+        return curve
+
+    if static_priv is not None:
+        curve = check_curve(curve, static_priv, 'static_priv', True)
+        count_priv += 1
+
+    if static_pub is not None:
+        curve = check_curve(curve, static_pub, 'static_pub', False)
+        count_pub += 1
+
+    if eph_priv is not None:
+        curve = check_curve(curve, eph_priv, 'eph_priv', True)
+        count_priv += 1
+
+    if eph_pub is not None:
+        curve = check_curve(curve, eph_pub, 'eph_pub', False)
+        count_pub += 1
+
+    if (count_priv + count_pub) < 2 or count_priv == 0 or count_pub == 0:
+        raise ValueError("Too few keys for the ECDH key agreement")
+
+    Zs = b''
+    Ze = b''
+
+    if static_priv and static_pub:
+        # C(*, 2s)
+        Zs = _compute_ecdh(static_priv, static_pub)
+
+    if eph_priv and eph_pub:
+        # C(2e, 0s) or C(2e, 2s)
+        if bool(static_priv) != bool(static_pub):
+            raise ValueError("DH mode C(2e, 1s) is not supported")
+        Ze = _compute_ecdh(eph_priv, eph_pub)
+    elif eph_priv and static_pub:
+        # C(1e, 2s) or C(1e, 1s)
+        Ze = _compute_ecdh(eph_priv, static_pub)
+    elif eph_pub and static_priv:
+        # C(1e, 2s) or C(1e, 1s)
+        Ze = _compute_ecdh(static_priv, eph_pub)
+
+    Z = Ze + Zs
+
+    return kdf(Z)

minigpt2/lib/python3.10/site-packages/Crypto/Protocol/KDF.py

@@ -0,0 +1,639 @@
+# coding=utf-8
+#
+#  KDF.py : a collection of Key Derivation Functions
+#
+# Part of the Python Cryptography Toolkit
+#
+# ===================================================================
+# The contents of this file are dedicated to the public domain.  To
+# the extent that dedication to the public domain is not available,
+# everyone is granted a worldwide, perpetual, royalty-free,
+# non-exclusive license to exercise all rights associated with the
+# contents of this file for any purpose whatsoever.
+# No rights are reserved.
+#
+# 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.
+# ===================================================================
+
+import re
+import struct
+from functools import reduce
+
+from Crypto.Util.py3compat import (tobytes, bord, _copy_bytes, iter_range,
+                                   tostr, bchr, bstr)
+
+from Crypto.Hash import SHA1, SHA256, HMAC, CMAC, BLAKE2s
+from Crypto.Util.strxor import strxor
+from Crypto.Random import get_random_bytes
+from Crypto.Util.number import size as bit_size, long_to_bytes, bytes_to_long
+
+from Crypto.Util._raw_api import (load_pycryptodome_raw_lib,
+                                  create_string_buffer,
+                                  get_raw_buffer, c_size_t)
+
+_raw_salsa20_lib = load_pycryptodome_raw_lib("Crypto.Cipher._Salsa20",
+                    """
+                    int Salsa20_8_core(const uint8_t *x, const uint8_t *y,
+                                       uint8_t *out);
+                    """)
+
+_raw_scrypt_lib = load_pycryptodome_raw_lib("Crypto.Protocol._scrypt",
+                    """
+                    typedef int (core_t)(const uint8_t [64], const uint8_t [64], uint8_t [64]);
+                    int scryptROMix(const uint8_t *data_in, uint8_t *data_out,
+                           size_t data_len, unsigned N, core_t *core);
+                    """)
+
+
+def PBKDF1(password, salt, dkLen, count=1000, hashAlgo=None):
+    """Derive one key from a password (or passphrase).
+
+    This function performs key derivation according to an old version of
+    the PKCS#5 standard (v1.5) or `RFC2898
+    <https://www.ietf.org/rfc/rfc2898.txt>`_.
+
+    Args:
+     password (string):
+        The secret password to generate the key from.
+     salt (byte string):
+        An 8 byte string to use for better protection from dictionary attacks.
+        This value does not need to be kept secret, but it should be randomly
+        chosen for each derivation.
+     dkLen (integer):
+        The length of the desired key. The default is 16 bytes, suitable for
+        instance for :mod:`Crypto.Cipher.AES`.
+     count (integer):
+        The number of iterations to carry out. The recommendation is 1000 or
+        more.
+     hashAlgo (module):
+        The hash algorithm to use, as a module or an object from the :mod:`Crypto.Hash` package.
+        The digest length must be no shorter than ``dkLen``.
+        The default algorithm is :mod:`Crypto.Hash.SHA1`.
+
+    Return:
+        A byte string of length ``dkLen`` that can be used as key.
+    """
+
+    if not hashAlgo:
+        hashAlgo = SHA1
+    password = tobytes(password)
+    pHash = hashAlgo.new(password+salt)
+    digest = pHash.digest_size
+    if dkLen > digest:
+        raise TypeError("Selected hash algorithm has a too short digest (%d bytes)." % digest)
+    if len(salt) != 8:
+        raise ValueError("Salt is not 8 bytes long (%d bytes instead)." % len(salt))
+    for i in iter_range(count-1):
+        pHash = pHash.new(pHash.digest())
+    return pHash.digest()[:dkLen]
+
+
+def PBKDF2(password, salt, dkLen=16, count=1000, prf=None, hmac_hash_module=None):
+    """Derive one or more keys from a password (or passphrase).
+
+    This function performs key derivation according to the PKCS#5 standard (v2.0).
+
+    Args:
+     password (string or byte string):
+        The secret password to generate the key from.
+
+        Strings will be encoded as ISO 8859-1 (also known as Latin-1),
+        which does not allow any characters with codepoints > 255.
+     salt (string or byte string):
+        A (byte) string to use for better protection from dictionary attacks.
+        This value does not need to be kept secret, but it should be randomly
+        chosen for each derivation. It is recommended to use at least 16 bytes.
+
+        Strings will be encoded as ISO 8859-1 (also known as Latin-1),
+        which does not allow any characters with codepoints > 255.
+     dkLen (integer):
+        The cumulative length of the keys to produce.
+
+        Due to a flaw in the PBKDF2 design, you should not request more bytes
+        than the ``prf`` can output. For instance, ``dkLen`` should not exceed
+        20 bytes in combination with ``HMAC-SHA1``.
+     count (integer):
+        The number of iterations to carry out. The higher the value, the slower
+        and the more secure the function becomes.
+
+        You should find the maximum number of iterations that keeps the
+        key derivation still acceptable on the slowest hardware you must support.
+
+        Although the default value is 1000, **it is recommended to use at least
+        1000000 (1 million) iterations**.
+     prf (callable):
+        A pseudorandom function. It must be a function that returns a
+        pseudorandom byte string from two parameters: a secret and a salt.
+        The slower the algorithm, the more secure the derivation function.
+        If not specified, **HMAC-SHA1** is used.
+     hmac_hash_module (module):
+        A module from ``Crypto.Hash`` implementing a Merkle-Damgard cryptographic
+        hash, which PBKDF2 must use in combination with HMAC.
+        This parameter is mutually exclusive with ``prf``.
+
+    Return:
+        A byte string of length ``dkLen`` that can be used as key material.
+        If you want multiple keys, just break up this string into segments of the desired length.
+    """
+
+    password = tobytes(password)
+    salt = tobytes(salt)
+
+    if prf and hmac_hash_module:
+        raise ValueError("'prf' and 'hmac_hash_module' are mutually exlusive")
+
+    if prf is None and hmac_hash_module is None:
+        hmac_hash_module = SHA1
+
+    if prf or not hasattr(hmac_hash_module, "_pbkdf2_hmac_assist"):
+        # Generic (and slow) implementation
+
+        if prf is None:
+            prf = lambda p,s: HMAC.new(p, s, hmac_hash_module).digest()
+
+        def link(s):
+            s[0], s[1] = s[1], prf(password, s[1])
+            return s[0]
+
+        key = b''
+        i = 1
+        while len(key) < dkLen:
+            s = [ prf(password, salt + struct.pack(">I", i)) ] * 2
+            key += reduce(strxor, (link(s) for j in range(count)) )
+            i += 1
+
+    else:
+        # Optimized implementation
+        key = b''
+        i = 1
+        while len(key)<dkLen:
+            base = HMAC.new(password, b"", hmac_hash_module)
+            first_digest = base.copy().update(salt + struct.pack(">I", i)).digest()
+            key += base._pbkdf2_hmac_assist(first_digest, count)
+            i += 1
+
+    return key[:dkLen]
+
+
+class _S2V(object):
+    """String-to-vector PRF as defined in `RFC5297`_.
+
+    This class implements a pseudorandom function family
+    based on CMAC that takes as input a vector of strings.
+
+    .. _RFC5297: http://tools.ietf.org/html/rfc5297
+    """
+
+    def __init__(self, key, ciphermod, cipher_params=None):
+        """Initialize the S2V PRF.
+
+        :Parameters:
+          key : byte string
+            A secret that can be used as key for CMACs
+            based on ciphers from ``ciphermod``.
+          ciphermod : module
+            A block cipher module from `Crypto.Cipher`.
+          cipher_params : dictionary
+            A set of extra parameters to use to create a cipher instance.
+        """
+
+        self._key = _copy_bytes(None, None, key)
+        self._ciphermod = ciphermod
+        self._last_string = self._cache = b'\x00' * ciphermod.block_size
+
+        # Max number of update() call we can process
+        self._n_updates = ciphermod.block_size * 8 - 1
+
+        if cipher_params is None:
+            self._cipher_params = {}
+        else:
+            self._cipher_params = dict(cipher_params)
+
+    @staticmethod
+    def new(key, ciphermod):
+        """Create a new S2V PRF.
+
+        :Parameters:
+          key : byte string
+            A secret that can be used as key for CMACs
+            based on ciphers from ``ciphermod``.
+          ciphermod : module
+            A block cipher module from `Crypto.Cipher`.
+        """
+        return _S2V(key, ciphermod)
+
+    def _double(self, bs):
+        doubled = bytes_to_long(bs)<<1
+        if bord(bs[0]) & 0x80:
+            doubled ^= 0x87
+        return long_to_bytes(doubled, len(bs))[-len(bs):]
+
+    def update(self, item):
+        """Pass the next component of the vector.
+
+        The maximum number of components you can pass is equal to the block
+        length of the cipher (in bits) minus 1.
+
+        :Parameters:
+          item : byte string
+            The next component of the vector.
+        :Raise TypeError: when the limit on the number of components has been reached.
+        """
+
+        if self._n_updates == 0:
+            raise TypeError("Too many components passed to S2V")
+        self._n_updates -= 1
+
+        mac = CMAC.new(self._key,
+                       msg=self._last_string,
+                       ciphermod=self._ciphermod,
+                       cipher_params=self._cipher_params)
+        self._cache = strxor(self._double(self._cache), mac.digest())
+        self._last_string = _copy_bytes(None, None, item)
+
+    def derive(self):
+        """"Derive a secret from the vector of components.
+
+        :Return: a byte string, as long as the block length of the cipher.
+        """
+
+        if len(self._last_string) >= 16:
+            # xorend
+            final = self._last_string[:-16] + strxor(self._last_string[-16:], self._cache)
+        else:
+            # zero-pad & xor
+            padded = (self._last_string + b'\x80' + b'\x00' * 15)[:16]
+            final = strxor(padded, self._double(self._cache))
+        mac = CMAC.new(self._key,
+                       msg=final,
+                       ciphermod=self._ciphermod,
+                       cipher_params=self._cipher_params)
+        return mac.digest()
+
+
+def HKDF(master, key_len, salt, hashmod, num_keys=1, context=None):
+    """Derive one or more keys from a master secret using
+    the HMAC-based KDF defined in RFC5869_.
+
+    Args:
+     master (byte string):
+        The unguessable value used by the KDF to generate the other keys.
+        It must be a high-entropy secret, though not necessarily uniform.
+        It must not be a password.
+     key_len (integer):
+        The length in bytes of every derived key.
+     salt (byte string):
+        A non-secret, reusable value that strengthens the randomness
+        extraction step.
+        Ideally, it is as long as the digest size of the chosen hash.
+        If empty, a string of zeroes in used.
+     hashmod (module):
+        A cryptographic hash algorithm from :mod:`Crypto.Hash`.
+        :mod:`Crypto.Hash.SHA512` is a good choice.
+     num_keys (integer):
+        The number of keys to derive. Every key is :data:`key_len` bytes long.
+        The maximum cumulative length of all keys is
+        255 times the digest size.
+     context (byte string):
+        Optional identifier describing what the keys are used for.
+
+    Return:
+        A byte string or a tuple of byte strings.
+
+    .. _RFC5869: http://tools.ietf.org/html/rfc5869
+    """
+
+    output_len = key_len * num_keys
+    if output_len > (255 * hashmod.digest_size):
+        raise ValueError("Too much secret data to derive")
+    if not salt:
+        salt = b'\x00' * hashmod.digest_size
+    if context is None:
+        context = b""
+
+    # Step 1: extract
+    hmac = HMAC.new(salt, master, digestmod=hashmod)
+    prk = hmac.digest()
+
+    # Step 2: expand
+    t = [ b"" ]
+    n = 1
+    tlen = 0
+    while tlen < output_len:
+        hmac = HMAC.new(prk, t[-1] + context + struct.pack('B', n), digestmod=hashmod)
+        t.append(hmac.digest())
+        tlen += hashmod.digest_size
+        n += 1
+    derived_output = b"".join(t)
+    if num_keys == 1:
+        return derived_output[:key_len]
+    kol = [derived_output[idx:idx + key_len]
+           for idx in iter_range(0, output_len, key_len)]
+    return list(kol[:num_keys])
+
+
+
+def scrypt(password, salt, key_len, N, r, p, num_keys=1):
+    """Derive one or more keys from a passphrase.
+
+    Args:
+     password (string):
+        The secret pass phrase to generate the keys from.
+     salt (string):
+        A string to use for better protection from dictionary attacks.
+        This value does not need to be kept secret,
+        but it should be randomly chosen for each derivation.
+        It is recommended to be at least 16 bytes long.
+     key_len (integer):
+        The length in bytes of each derived key.
+     N (integer):
+        CPU/Memory cost parameter. It must be a power of 2 and less
+        than :math:`2^{32}`.
+     r (integer):
+        Block size parameter.
+     p (integer):
+        Parallelization parameter.
+        It must be no greater than :math:`(2^{32}-1)/(4r)`.
+     num_keys (integer):
+        The number of keys to derive. Every key is :data:`key_len` bytes long.
+        By default, only 1 key is generated.
+        The maximum cumulative length of all keys is :math:`(2^{32}-1)*32`
+        (that is, 128TB).
+
+    A good choice of parameters *(N, r , p)* was suggested
+    by Colin Percival in his `presentation in 2009`__:
+
+    - *( 2¹⁴, 8, 1 )* for interactive logins (≤100ms)
+    - *( 2²⁰, 8, 1 )* for file encryption (≤5s)
+
+    Return:
+        A byte string or a tuple of byte strings.
+
+    .. __: http://www.tarsnap.com/scrypt/scrypt-slides.pdf
+    """
+
+    if 2 ** (bit_size(N) - 1) != N:
+        raise ValueError("N must be a power of 2")
+    if N >= 2 ** 32:
+        raise ValueError("N is too big")
+    if p > ((2 ** 32 - 1) * 32)  // (128 * r):
+        raise ValueError("p or r are too big")
+
+    prf_hmac_sha256 = lambda p, s: HMAC.new(p, s, SHA256).digest()
+
+    stage_1 = PBKDF2(password, salt, p * 128 * r, 1, prf=prf_hmac_sha256)
+
+    scryptROMix = _raw_scrypt_lib.scryptROMix
+    core = _raw_salsa20_lib.Salsa20_8_core
+
+    # Parallelize into p flows
+    data_out = []
+    for flow in iter_range(p):
+        idx = flow * 128 * r
+        buffer_out = create_string_buffer(128 * r)
+        result = scryptROMix(stage_1[idx : idx + 128 * r],
+                             buffer_out,
+                             c_size_t(128 * r),
+                             N,
+                             core)
+        if result:
+            raise ValueError("Error %X while running scrypt" % result)
+        data_out += [ get_raw_buffer(buffer_out) ]
+
+    dk = PBKDF2(password,
+                b"".join(data_out),
+                key_len * num_keys, 1,
+                prf=prf_hmac_sha256)
+
+    if num_keys == 1:
+        return dk
+
+    kol = [dk[idx:idx + key_len]
+           for idx in iter_range(0, key_len * num_keys, key_len)]
+    return kol
+
+
+def _bcrypt_encode(data):
+    s = "./ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789"
+
+    bits = []
+    for c in data:
+        bits_c = bin(bord(c))[2:].zfill(8)
+        bits.append(bstr(bits_c))
+    bits = b"".join(bits)
+
+    bits6 = [ bits[idx:idx+6] for idx in range(0, len(bits), 6) ]
+
+    result = []
+    for g in bits6[:-1]:
+        idx = int(g, 2)
+        result.append(s[idx])
+
+    g = bits6[-1]
+    idx = int(g, 2) << (6 - len(g))
+    result.append(s[idx])
+    result = "".join(result)
+
+    return tobytes(result)
+
+
+def _bcrypt_decode(data):
+    s = "./ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789"
+
+    bits = []
+    for c in tostr(data):
+        idx = s.find(c)
+        bits6 = bin(idx)[2:].zfill(6)
+        bits.append(bits6)
+    bits = "".join(bits)
+
+    modulo4 = len(data) % 4
+    if modulo4 == 1:
+        raise ValueError("Incorrect length")
+    elif modulo4 == 2:
+        bits = bits[:-4]
+    elif modulo4 == 3:
+        bits = bits[:-2]
+
+    bits8 = [ bits[idx:idx+8] for idx in range(0, len(bits), 8) ]
+
+    result = []
+    for g in bits8:
+        result.append(bchr(int(g, 2)))
+    result = b"".join(result)
+
+    return result
+
+
+def _bcrypt_hash(password, cost, salt, constant, invert):
+    from Crypto.Cipher import _EKSBlowfish
+
+    if len(password) > 72:
+        raise ValueError("The password is too long. It must be 72 bytes at most.")
+
+    if not (4 <= cost <= 31):
+        raise ValueError("bcrypt cost factor must be in the range 4..31")
+
+    cipher = _EKSBlowfish.new(password, _EKSBlowfish.MODE_ECB, salt, cost, invert)
+    ctext = constant
+    for _ in range(64):
+        ctext = cipher.encrypt(ctext)
+    return ctext
+
+
+def bcrypt(password, cost, salt=None):
+    """Hash a password into a key, using the OpenBSD bcrypt protocol.
+
+    Args:
+      password (byte string or string):
+        The secret password or pass phrase.
+        It must be at most 72 bytes long.
+        It must not contain the zero byte.
+        Unicode strings will be encoded as UTF-8.
+      cost (integer):
+        The exponential factor that makes it slower to compute the hash.
+        It must be in the range 4 to 31.
+        A value of at least 12 is recommended.
+      salt (byte string):
+        Optional. Random byte string to thwarts dictionary and rainbow table
+        attacks. It must be 16 bytes long.
+        If not passed, a random value is generated.
+
+    Return (byte string):
+        The bcrypt hash
+
+    Raises:
+        ValueError: if password is longer than 72 bytes or if it contains the zero byte
+
+   """
+
+    password = tobytes(password, "utf-8")
+
+    if password.find(bchr(0)[0]) != -1:
+        raise ValueError("The password contains the zero byte")
+
+    if len(password) < 72:
+        password += b"\x00"
+
+    if salt is None:
+        salt = get_random_bytes(16)
+    if len(salt) != 16:
+        raise ValueError("bcrypt salt must be 16 bytes long")
+
+    ctext = _bcrypt_hash(password, cost, salt, b"OrpheanBeholderScryDoubt", True)
+
+    cost_enc = b"$" + bstr(str(cost).zfill(2))
+    salt_enc = b"$" + _bcrypt_encode(salt)
+    hash_enc = _bcrypt_encode(ctext[:-1])     # only use 23 bytes, not 24
+    return b"$2a" + cost_enc + salt_enc + hash_enc
+
+
+def bcrypt_check(password, bcrypt_hash):
+    """Verify if the provided password matches the given bcrypt hash.
+
+    Args:
+      password (byte string or string):
+        The secret password or pass phrase to test.
+        It must be at most 72 bytes long.
+        It must not contain the zero byte.
+        Unicode strings will be encoded as UTF-8.
+      bcrypt_hash (byte string, bytearray):
+        The reference bcrypt hash the password needs to be checked against.
+
+    Raises:
+        ValueError: if the password does not match
+    """
+
+    bcrypt_hash = tobytes(bcrypt_hash)
+
+    if len(bcrypt_hash) != 60:
+        raise ValueError("Incorrect length of the bcrypt hash: %d bytes instead of 60" % len(bcrypt_hash))
+
+    if bcrypt_hash[:4] != b'$2a$':
+        raise ValueError("Unsupported prefix")
+
+    p = re.compile(br'\$2a\$([0-9][0-9])\$([A-Za-z0-9./]{22,22})([A-Za-z0-9./]{31,31})')
+    r = p.match(bcrypt_hash)
+    if not r:
+        raise ValueError("Incorrect bcrypt hash format")
+
+    cost = int(r.group(1))
+    if not (4 <= cost <= 31):
+        raise ValueError("Incorrect cost")
+
+    salt = _bcrypt_decode(r.group(2))
+
+    bcrypt_hash2  = bcrypt(password, cost, salt)
+
+    secret = get_random_bytes(16)
+
+    mac1 = BLAKE2s.new(digest_bits=160, key=secret, data=bcrypt_hash).digest()
+    mac2 = BLAKE2s.new(digest_bits=160, key=secret, data=bcrypt_hash2).digest()
+    if mac1 != mac2:
+        raise ValueError("Incorrect bcrypt hash")
+
+
+def SP800_108_Counter(master, key_len, prf, num_keys=None, label=b'', context=b''):
+    """Derive one or more keys from a master secret using
+    a pseudorandom function in Counter Mode, as specified in
+    `NIST SP 800-108r1 <https://nvlpubs.nist.gov/nistpubs/SpecialPublications/NIST.SP.800-108r1.pdf>`_.
+
+    Args:
+     master (byte string):
+        The secret value used by the KDF to derive the other keys.
+        It must not be a password.
+        The length on the secret must be consistent with the input expected by
+        the :data:`prf` function.
+     key_len (integer):
+        The length in bytes of each derived key.
+     prf (function):
+        A pseudorandom function that takes two byte strings as parameters:
+        the secret and an input. It returns another byte string.
+     num_keys (integer):
+        The number of keys to derive. Every key is :data:`key_len` bytes long.
+        By default, only 1 key is derived.
+     label (byte string):
+        Optional description of the purpose of the derived keys.
+        It must not contain zero bytes.
+     context (byte string):
+        Optional information pertaining to
+        the protocol that uses the keys, such as the identity of the
+        participants, nonces, session IDs, etc.
+        It must not contain zero bytes.
+
+    Return:
+        - a byte string (if ``num_keys`` is not specified), or
+        - a tuple of byte strings (if ``num_key`` is specified).
+    """
+
+    if num_keys is None:
+        num_keys = 1
+
+    if context.find(b'\x00') != -1:
+        raise ValueError("Null byte found in context")
+
+    key_len_enc = long_to_bytes(key_len * num_keys * 8, 4)
+    output_len = key_len * num_keys
+
+    i = 1
+    dk = b""
+    while len(dk) < output_len:
+        info = long_to_bytes(i, 4) + label + b'\x00' + context + key_len_enc
+        dk += prf(master, info)
+        i += 1
+        if i > 0xFFFFFFFF:
+            raise ValueError("Overflow in SP800 108 counter")
+
+    if num_keys == 1:
+        return dk[:key_len]
+    else:
+        kol = [dk[idx:idx + key_len]
+               for idx in iter_range(0, output_len, key_len)]
+        return kol

minigpt2/lib/python3.10/site-packages/Crypto/Protocol/KDF.pyi

@@ -0,0 +1,42 @@
+from types import ModuleType
+from typing import Optional, Callable, Tuple, Union, Dict, Any, overload
+from typing_extensions import Literal
+
+Buffer=bytes|bytearray|memoryview
+
+RNG = Callable[[int], bytes]
+PRF = Callable[[bytes, bytes], bytes]
+
+def PBKDF1(password: str, salt: bytes, dkLen: int, count: Optional[int]=1000, hashAlgo: Optional[ModuleType]=None) -> bytes: ...
+def PBKDF2(password: str, salt: bytes, dkLen: Optional[int]=16, count: Optional[int]=1000, prf: Optional[RNG]=None, hmac_hash_module: Optional[ModuleType]=None) -> bytes: ...
+
+class _S2V(object):
+    def __init__(self, key: bytes, ciphermod: ModuleType, cipher_params: Optional[Dict[Any, Any]]=None) -> None: ...
+
+    @staticmethod
+    def new(key: bytes, ciphermod: ModuleType) -> None: ...
+    def update(self, item: bytes) -> None: ...
+    def derive(self) -> bytes: ...
+
+def HKDF(master: bytes, key_len: int, salt: bytes, hashmod: ModuleType, num_keys: Optional[int]=1, context: Optional[bytes]=None) -> Union[bytes, Tuple[bytes, ...]]: ...
+
+def scrypt(password: str, salt: str, key_len: int, N: int, r: int, p: int, num_keys: Optional[int]=1) -> Union[bytes, Tuple[bytes, ...]]: ...
+
+def _bcrypt_decode(data: bytes) -> bytes: ...
+def _bcrypt_hash(password:bytes , cost: int, salt: bytes, constant:bytes, invert:bool) -> bytes: ...
+def bcrypt(password: Union[bytes, str], cost: int, salt: Optional[bytes]=None) -> bytes: ...
+def bcrypt_check(password: Union[bytes, str], bcrypt_hash: Union[bytes, bytearray, str]) -> None: ...
+
+@overload
+def SP800_108_Counter(master: Buffer,
+                      key_len: int,
+                      prf: PRF,
+                      num_keys: Literal[None] = None,
+                      label: Buffer = b'', context: Buffer = b'') -> bytes: ...
+
+@overload
+def SP800_108_Counter(master: Buffer,
+                      key_len: int,
+                      prf: PRF,
+                      num_keys: int,
+                      label: Buffer = b'', context: Buffer = b'') -> Tuple[bytes]: ...

minigpt2/lib/python3.10/site-packages/Crypto/Protocol/SecretSharing.py

@@ -0,0 +1,278 @@
+#
+# SecretSharing.py : distribute a secret amongst a group of participants
+#
+# ===================================================================
+#
+# Copyright (c) 2014, Legrandin <helderijs@gmail.com>
+# All rights reserved.
+#
+# Redistribution and use in source and binary forms, with or without
+# modification, are permitted provided that the following conditions
+# are met:
+#
+# 1. Redistributions of source code must retain the above copyright
+#    notice, this list of conditions and the following disclaimer.
+# 2. Redistributions in binary form must reproduce the above copyright
+#    notice, this list of conditions and the following disclaimer in
+#    the documentation and/or other materials provided with the
+#    distribution.
+#
+# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+# "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+# LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
+# FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
+# COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
+# INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
+# BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+# LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+# CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+# LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
+# ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+# POSSIBILITY OF SUCH DAMAGE.
+# ===================================================================
+
+from Crypto.Util.py3compat import is_native_int
+from Crypto.Util import number
+from Crypto.Util.number import long_to_bytes, bytes_to_long
+from Crypto.Random import get_random_bytes as rng
+
+
+def _mult_gf2(f1, f2):
+    """Multiply two polynomials in GF(2)"""
+
+    # Ensure f2 is the smallest
+    if f2 > f1:
+        f1, f2 = f2, f1
+    z = 0
+    while f2:
+        if f2 & 1:
+            z ^= f1
+        f1 <<= 1
+        f2 >>= 1
+    return z
+
+
+def _div_gf2(a, b):
+    """
+    Compute division of polynomials over GF(2).
+    Given a and b, it finds two polynomials q and r such that:
+
+    a = b*q + r with deg(r)<deg(b)
+    """
+
+    if (a < b):
+        return 0, a
+
+    deg = number.size
+    q = 0
+    r = a
+    d = deg(b)
+    while deg(r) >= d:
+        s = 1 << (deg(r) - d)
+        q ^= s
+        r ^= _mult_gf2(b, s)
+    return (q, r)
+
+
+class _Element(object):
+    """Element of GF(2^128) field"""
+
+    # The irreducible polynomial defining this field is 1+x+x^2+x^7+x^128
+    irr_poly = 1 + 2 + 4 + 128 + 2 ** 128
+
+    def __init__(self, encoded_value):
+        """Initialize the element to a certain value.
+
+        The value passed as parameter is internally encoded as
+        a 128-bit integer, where each bit represents a polynomial
+        coefficient. The LSB is the constant coefficient.
+        """
+
+        if is_native_int(encoded_value):
+            self._value = encoded_value
+        elif len(encoded_value) == 16:
+            self._value = bytes_to_long(encoded_value)
+        else:
+            raise ValueError("The encoded value must be an integer or a 16 byte string")
+
+    def __eq__(self, other):
+        return self._value == other._value
+
+    def __int__(self):
+        """Return the field element, encoded as a 128-bit integer."""
+        return self._value
+
+    def encode(self):
+        """Return the field element, encoded as a 16 byte string."""
+        return long_to_bytes(self._value, 16)
+
+    def __mul__(self, factor):
+
+        f1 = self._value
+        f2 = factor._value
+
+        # Make sure that f2 is the smallest, to speed up the loop
+        if f2 > f1:
+            f1, f2 = f2, f1
+
+        if self.irr_poly in (f1, f2):
+            return _Element(0)
+
+        mask1 = 2 ** 128
+        v, z = f1, 0
+        while f2:
+            # if f2 ^ 1: z ^= v
+            mask2 = int(bin(f2 & 1)[2:] * 128, base=2)
+            z = (mask2 & (z ^ v)) | ((mask1 - mask2 - 1) & z)
+            v <<= 1
+            # if v & mask1: v ^= self.irr_poly
+            mask3 = int(bin((v >> 128) & 1)[2:] * 128, base=2)
+            v = (mask3 & (v ^ self.irr_poly)) | ((mask1 - mask3 - 1) & v)
+            f2 >>= 1
+        return _Element(z)
+
+    def __add__(self, term):
+        return _Element(self._value ^ term._value)
+
+    def inverse(self):
+        """Return the inverse of this element in GF(2^128)."""
+
+        # We use the Extended GCD algorithm
+        # http://en.wikipedia.org/wiki/Polynomial_greatest_common_divisor
+
+        if self._value == 0:
+            raise ValueError("Inversion of zero")
+
+        r0, r1 = self._value, self.irr_poly
+        s0, s1 = 1, 0
+        while r1 > 0:
+            q = _div_gf2(r0, r1)[0]
+            r0, r1 = r1, r0 ^ _mult_gf2(q, r1)
+            s0, s1 = s1, s0 ^ _mult_gf2(q, s1)
+        return _Element(s0)
+
+    def __pow__(self, exponent):
+        result = _Element(self._value)
+        for _ in range(exponent - 1):
+            result = result * self
+        return result
+
+
+class Shamir(object):
+    """Shamir's secret sharing scheme.
+
+    A secret is split into ``n`` shares, and it is sufficient to collect
+    ``k`` of them to reconstruct the secret.
+    """
+
+    @staticmethod
+    def split(k, n, secret, ssss=False):
+        """Split a secret into ``n`` shares.
+
+        The secret can be reconstructed later using just ``k`` shares
+        out of the original ``n``.
+        Each share must be kept confidential to the person it was
+        assigned to.
+
+        Each share is associated to an index (starting from 1).
+
+        Args:
+          k (integer):
+            The sufficient number of shares to reconstruct the secret (``k < n``).
+          n (integer):
+            The number of shares that this method will create.
+          secret (byte string):
+            A byte string of 16 bytes (e.g. the AES 128 key).
+          ssss (bool):
+            If ``True``, the shares can be used with the ``ssss`` utility.
+            Default: ``False``.
+
+        Return (tuples):
+            ``n`` tuples. A tuple is meant for each participant and it contains two items:
+
+            1. the unique index (an integer)
+            2. the share (a byte string, 16 bytes)
+        """
+
+        #
+        # We create a polynomial with random coefficients in GF(2^128):
+        #
+        # p(x) = \sum_{i=0}^{k-1} c_i * x^i
+        #
+        # c_0 is the encoded secret
+        #
+
+        coeffs = [_Element(rng(16)) for i in range(k - 1)]
+        coeffs.append(_Element(secret))
+
+        # Each share is y_i = p(x_i) where x_i is the public index
+        # associated to each of the n users.
+
+        def make_share(user, coeffs, ssss):
+            idx = _Element(user)
+            share = _Element(0)
+            for coeff in coeffs:
+                share = idx * share + coeff
+            if ssss:
+                share += _Element(user) ** len(coeffs)
+            return share.encode()
+
+        return [(i, make_share(i, coeffs, ssss)) for i in range(1, n + 1)]
+
+    @staticmethod
+    def combine(shares, ssss=False):
+        """Recombine a secret, if enough shares are presented.
+
+        Args:
+          shares (tuples):
+            The *k* tuples, each containin the index (an integer) and
+            the share (a byte string, 16 bytes long) that were assigned to
+            a participant.
+          ssss (bool):
+            If ``True``, the shares were produced by the ``ssss`` utility.
+            Default: ``False``.
+
+        Return:
+            The original secret, as a byte string (16 bytes long).
+        """
+
+        #
+        # Given k points (x,y), the interpolation polynomial of degree k-1 is:
+        #
+        # L(x) = \sum_{j=0}^{k-1} y_i * l_j(x)
+        #
+        # where:
+        #
+        # l_j(x) = \prod_{ \overset{0 \le m \le k-1}{m \ne j} }
+        #          \frac{x - x_m}{x_j - x_m}
+        #
+        # However, in this case we are purely interested in the constant
+        # coefficient of L(x).
+        #
+
+        k = len(shares)
+
+        gf_shares = []
+        for x in shares:
+            idx = _Element(x[0])
+            value = _Element(x[1])
+            if any(y[0] == idx for y in gf_shares):
+                raise ValueError("Duplicate share")
+            if ssss:
+                value += idx ** k
+            gf_shares.append((idx, value))
+
+        result = _Element(0)
+        for j in range(k):
+            x_j, y_j = gf_shares[j]
+
+            numerator = _Element(1)
+            denominator = _Element(1)
+
+            for m in range(k):
+                x_m = gf_shares[m][0]
+                if m != j:
+                    numerator *= x_m
+                    denominator *= x_j + x_m
+            result += y_j * numerator * denominator.inverse()
+        return result.encode()

minigpt2/lib/python3.10/site-packages/Crypto/Protocol/__init__.py

@@ -0,0 +1,31 @@
+# ===================================================================
+#
+# Copyright (c) 2014, Legrandin <helderijs@gmail.com>
+# All rights reserved.
+#
+# Redistribution and use in source and binary forms, with or without
+# modification, are permitted provided that the following conditions
+# are met:
+#
+# 1. Redistributions of source code must retain the above copyright
+#    notice, this list of conditions and the following disclaimer.
+# 2. Redistributions in binary form must reproduce the above copyright
+#    notice, this list of conditions and the following disclaimer in
+#    the documentation and/or other materials provided with the
+#    distribution.
+#
+# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+# "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+# LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
+# FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
+# COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
+# INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
+# BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+# LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+# CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+# LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
+# ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+# POSSIBILITY OF SUCH DAMAGE.
+# ===================================================================
+
+__all__ = ['KDF', 'SecretSharing', 'DH']

minigpt2/lib/python3.10/site-packages/Crypto/Protocol/__init__.pyi

@@ -0,0 +1 @@
+__all__ = ['KDF.pyi', 'SecretSharing.pyi']

minigpt2/lib/python3.10/site-packages/Crypto/Random/__init__.py

@@ -0,0 +1,57 @@
+# -*- coding: utf-8 -*-
+#
+#  Random/__init__.py : PyCrypto random number generation
+#
+# ===================================================================
+# The contents of this file are dedicated to the public domain.  To
+# the extent that dedication to the public domain is not available,
+# everyone is granted a worldwide, perpetual, royalty-free,
+# non-exclusive license to exercise all rights associated with the
+# contents of this file for any purpose whatsoever.
+# No rights are reserved.
+#
+# 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.
+# ===================================================================
+
+__all__ = ['new', 'get_random_bytes']
+
+from os import urandom
+
+class _UrandomRNG(object):
+
+    def read(self, n):
+        """Return a random byte string of the desired size."""
+        return urandom(n)
+
+    def flush(self):
+        """Method provided for backward compatibility only."""
+        pass
+
+    def reinit(self):
+        """Method provided for backward compatibility only."""
+        pass
+
+    def close(self):
+        """Method provided for backward compatibility only."""
+        pass
+        
+
+def new(*args, **kwargs):
+    """Return a file-like object that outputs cryptographically random bytes."""
+    return _UrandomRNG()
+
+
+def atfork():
+    pass
+
+
+#: Function that returns a random byte string of the desired size.
+get_random_bytes = urandom
+

minigpt2/lib/python3.10/site-packages/Crypto/Random/__init__.pyi

@@ -0,0 +1,19 @@
+from typing import Any
+
+__all__ = ['new', 'get_random_bytes']
+
+from os import urandom
+
+class _UrandomRNG(object):
+
+    def read(self, n: int) -> bytes:...
+    def flush(self) -> None: ...
+    def reinit(self) -> None: ...
+    def close(self) -> None: ...
+
+def new(*args: Any, **kwargs: Any) -> _UrandomRNG: ...
+
+def atfork() -> None: ...
+
+get_random_bytes = urandom
+

minigpt2/lib/python3.10/site-packages/Crypto/Random/random.py

@@ -0,0 +1,138 @@
+# -*- coding: utf-8 -*-
+#
+#  Random/random.py : Strong alternative for the standard 'random' module
+#
+# Written in 2008 by Dwayne C. Litzenberger <dlitz@dlitz.net>
+#
+# ===================================================================
+# The contents of this file are dedicated to the public domain.  To
+# the extent that dedication to the public domain is not available,
+# everyone is granted a worldwide, perpetual, royalty-free,
+# non-exclusive license to exercise all rights associated with the
+# contents of this file for any purpose whatsoever.
+# No rights are reserved.
+#
+# 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.
+# ===================================================================
+
+__all__ = ['StrongRandom', 'getrandbits', 'randrange', 'randint', 'choice', 'shuffle', 'sample']
+
+from Crypto import Random
+
+from Crypto.Util.py3compat import is_native_int
+
+class StrongRandom(object):
+    def __init__(self, rng=None, randfunc=None):
+        if randfunc is None and rng is None:
+            self._randfunc = None
+        elif randfunc is not None and rng is None:
+            self._randfunc = randfunc
+        elif randfunc is None and rng is not None:
+            self._randfunc = rng.read
+        else:
+            raise ValueError("Cannot specify both 'rng' and 'randfunc'")
+
+    def getrandbits(self, k):
+        """Return an integer with k random bits."""
+
+        if self._randfunc is None:
+            self._randfunc = Random.new().read
+        mask = (1 << k) - 1
+        return mask & bytes_to_long(self._randfunc(ceil_div(k, 8)))
+
+    def randrange(self, *args):
+        """randrange([start,] stop[, step]):
+        Return a randomly-selected element from range(start, stop, step)."""
+        if len(args) == 3:
+            (start, stop, step) = args
+        elif len(args) == 2:
+            (start, stop) = args
+            step = 1
+        elif len(args) == 1:
+            (stop,) = args
+            start = 0
+            step = 1
+        else:
+            raise TypeError("randrange expected at most 3 arguments, got %d" % (len(args),))
+        if (not is_native_int(start) or not is_native_int(stop) or not
+                is_native_int(step)):
+            raise TypeError("randrange requires integer arguments")
+        if step == 0:
+            raise ValueError("randrange step argument must not be zero")
+
+        num_choices = ceil_div(stop - start, step)
+        if num_choices < 0:
+            num_choices = 0
+        if num_choices < 1:
+            raise ValueError("empty range for randrange(%r, %r, %r)" % (start, stop, step))
+
+        # Pick a random number in the range of possible numbers
+        r = num_choices
+        while r >= num_choices:
+            r = self.getrandbits(size(num_choices))
+
+        return start + (step * r)
+
+    def randint(self, a, b):
+        """Return a random integer N such that a <= N <= b."""
+        if not is_native_int(a) or not is_native_int(b):
+            raise TypeError("randint requires integer arguments")
+        N = self.randrange(a, b+1)
+        assert a <= N <= b
+        return N
+
+    def choice(self, seq):
+        """Return a random element from a (non-empty) sequence.
+
+        If the seqence is empty, raises IndexError.
+        """
+        if len(seq) == 0:
+            raise IndexError("empty sequence")
+        return seq[self.randrange(len(seq))]
+
+    def shuffle(self, x):
+        """Shuffle the sequence in place."""
+        # Fisher-Yates shuffle.  O(n)
+        # See http://en.wikipedia.org/wiki/Fisher-Yates_shuffle
+        # Working backwards from the end of the array, we choose a random item
+        # from the remaining items until all items have been chosen.
+        for i in range(len(x)-1, 0, -1):   # iterate from len(x)-1 downto 1
+            j = self.randrange(0, i+1)      # choose random j such that 0 <= j <= i
+            x[i], x[j] = x[j], x[i]         # exchange x[i] and x[j]
+
+    def sample(self, population, k):
+        """Return a k-length list of unique elements chosen from the population sequence."""
+
+        num_choices = len(population)
+        if k > num_choices:
+            raise ValueError("sample larger than population")
+
+        retval = []
+        selected = {}  # we emulate a set using a dict here
+        for i in range(k):
+            r = None
+            while r is None or r in selected:
+                r = self.randrange(num_choices)
+            retval.append(population[r])
+            selected[r] = 1
+        return retval
+
+_r = StrongRandom()
+getrandbits = _r.getrandbits
+randrange = _r.randrange
+randint = _r.randint
+choice = _r.choice
+shuffle = _r.shuffle
+sample = _r.sample
+
+# These are at the bottom to avoid problems with recursive imports
+from Crypto.Util.number import ceil_div, bytes_to_long, long_to_bytes, size
+
+# vim:set ts=4 sw=4 sts=4 expandtab:

minigpt2/lib/python3.10/site-packages/Crypto/Random/random.pyi

@@ -0,0 +1,22 @@
+from typing import Callable, Tuple, Union, Sequence, Any, Optional, TypeVar
+
+__all__ = ['StrongRandom', 'getrandbits', 'randrange', 'randint', 'choice', 'shuffle', 'sample']
+
+T = TypeVar('T')
+
+class StrongRandom(object):
+    def __init__(self, rng: Optional[Any]=None, randfunc: Optional[Callable]=None) -> None: ... #  TODO What is rng?
+    def getrandbits(self, k: int) -> int: ...
+    def randrange(self, start: int, stop: int = ..., step: int = ...) -> int: ...
+    def randint(self, a: int, b: int) -> int: ...
+    def choice(self, seq: Sequence[T]) -> T: ...
+    def shuffle(self, x: Sequence) -> None: ...
+    def sample(self, population: Sequence, k: int) -> list: ...
+
+_r = StrongRandom()
+getrandbits = _r.getrandbits
+randrange = _r.randrange
+randint = _r.randint
+choice = _r.choice
+shuffle = _r.shuffle
+sample = _r.sample

minigpt2/lib/python3.10/site-packages/Crypto/SelfTest/IO/__init__.py

@@ -0,0 +1,47 @@
+#
+#  SelfTest/IO/__init__.py: Self-test for input/output module
+#
+# ===================================================================
+#
+# Copyright (c) 2014, Legrandin <helderijs@gmail.com>
+# All rights reserved.
+#
+# Redistribution and use in source and binary forms, with or without
+# modification, are permitted provided that the following conditions
+# are met:
+#
+# 1. Redistributions of source code must retain the above copyright
+#    notice, this list of conditions and the following disclaimer.
+# 2. Redistributions in binary form must reproduce the above copyright
+#    notice, this list of conditions and the following disclaimer in
+#    the documentation and/or other materials provided with the
+#    distribution.
+#
+# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+# "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+# LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
+# FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
+# COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
+# INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
+# BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+# LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+# CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+# LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
+# ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+# POSSIBILITY OF SUCH DAMAGE.
+# ===================================================================
+
+"""Self-test for I/O"""
+
+def get_tests(config={}):
+    tests = []
+    from Crypto.SelfTest.IO import test_PKCS8;     tests += test_PKCS8.get_tests(config=config)
+    from Crypto.SelfTest.IO import test_PBES;      tests += test_PBES.get_tests(config=config)
+    return tests
+
+if __name__ == '__main__':
+    import unittest
+    suite = lambda: unittest.TestSuite(get_tests())
+    unittest.main(defaultTest='suite')
+
+

minigpt2/lib/python3.10/site-packages/Crypto/SelfTest/Math/__init__.py

@@ -0,0 +1,51 @@
+#
+#  SelfTest/Math/__init__.py: Self-test for math module
+#
+# ===================================================================
+#
+# Copyright (c) 2014, Legrandin <helderijs@gmail.com>
+# All rights reserved.
+#
+# Redistribution and use in source and binary forms, with or without
+# modification, are permitted provided that the following conditions
+# are met:
+#
+# 1. Redistributions of source code must retain the above copyright
+#    notice, this list of conditions and the following disclaimer.
+# 2. Redistributions in binary form must reproduce the above copyright
+#    notice, this list of conditions and the following disclaimer in
+#    the documentation and/or other materials provided with the
+#    distribution.
+#
+# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+# "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+# LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
+# FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
+# COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
+# INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
+# BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+# LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+# CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+# LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
+# ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+# POSSIBILITY OF SUCH DAMAGE.
+# ===================================================================
+
+"""Self-test for Math"""
+
+def get_tests(config={}):
+    tests = []
+    from Crypto.SelfTest.Math import test_Numbers
+    from Crypto.SelfTest.Math import test_Primality
+    from Crypto.SelfTest.Math import test_modexp
+    from Crypto.SelfTest.Math import test_modmult
+    tests += test_Numbers.get_tests(config=config)
+    tests += test_Primality.get_tests(config=config)
+    tests += test_modexp.get_tests(config=config)
+    tests += test_modmult.get_tests(config=config)
+    return tests
+
+if __name__ == '__main__':
+    import unittest
+    suite = lambda: unittest.TestSuite(get_tests())
+    unittest.main(defaultTest='suite')

minigpt2/lib/python3.10/site-packages/Crypto/SelfTest/Math/test_Numbers.py

@@ -0,0 +1,838 @@
+#
+#  SelfTest/Math/test_Numbers.py: Self-test for Numbers module
+#
+# ===================================================================
+#
+# Copyright (c) 2014, Legrandin <helderijs@gmail.com>
+# All rights reserved.
+#
+# Redistribution and use in source and binary forms, with or without
+# modification, are permitted provided that the following conditions
+# are met:
+#
+# 1. Redistributions of source code must retain the above copyright
+#    notice, this list of conditions and the following disclaimer.
+# 2. Redistributions in binary form must reproduce the above copyright
+#    notice, this list of conditions and the following disclaimer in
+#    the documentation and/or other materials provided with the
+#    distribution.
+#
+# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+# "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+# LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
+# FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
+# COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
+# INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
+# BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+# LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+# CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+# LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
+# ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+# POSSIBILITY OF SUCH DAMAGE.
+# ===================================================================
+
+"""Self-test for Math.Numbers"""
+
+import sys
+import unittest
+
+from Crypto.SelfTest.st_common import list_test_cases
+
+from Crypto.Util.py3compat import *
+
+from Crypto.Math._IntegerNative import IntegerNative
+
+
+class TestIntegerBase(unittest.TestCase):
+
+    def setUp(self):
+        raise NotImplementedError("To be implemented")
+
+    def Integers(self, *arg):
+        return map(self.Integer, arg)
+
+    def test_init_and_equality(self):
+        Integer = self.Integer
+
+        v1 = Integer(23)
+        v2 = Integer(v1)
+        v3 = Integer(-9)
+        self.assertRaises(ValueError, Integer, 1.0)
+
+        v4 = Integer(10**10)
+        v5 = Integer(-10**10)
+
+        v6 = Integer(0xFFFF)
+        v7 = Integer(0xFFFFFFFF)
+        v8 = Integer(0xFFFFFFFFFFFFFFFF)
+
+        self.assertEqual(v1, v1)
+        self.assertEqual(v1, 23)
+        self.assertEqual(v1, v2)
+        self.assertEqual(v3, -9)
+        self.assertEqual(v4, 10 ** 10)
+        self.assertEqual(v5, -10 ** 10)
+        self.assertEqual(v6, 0xFFFF)
+        self.assertEqual(v7, 0xFFFFFFFF)
+        self.assertEqual(v8, 0xFFFFFFFFFFFFFFFF)
+
+        self.assertFalse(v1 == v4)
+
+        # Init and comparison between Integer's
+        v6 = Integer(v1)
+        self.assertEqual(v1, v6)
+
+        self.assertFalse(Integer(0) == None)
+
+    def test_conversion_to_int(self):
+        v1, v2 = self.Integers(-23, 2 ** 1000)
+        self.assertEqual(int(v1), -23)
+        self.assertEqual(int(v2), 2 ** 1000)
+
+    def test_equality_with_ints(self):
+        v1, v2, v3 = self.Integers(23, -89, 2 ** 1000)
+        self.assertTrue(v1 == 23)
+        self.assertTrue(v2 == -89)
+        self.assertFalse(v1 == 24)
+        self.assertTrue(v3 == 2 ** 1000)
+
+    def test_conversion_to_str(self):
+        v1, v2, v3, v4 = self.Integers(20, 0, -20, 2 ** 1000)
+        self.assertTrue(str(v1) == "20")
+        self.assertTrue(str(v2) == "0")
+        self.assertTrue(str(v3) == "-20")
+        self.assertTrue(str(v4) == "10715086071862673209484250490600018105614048117055336074437503883703510511249361224931983788156958581275946729175531468251871452856923140435984577574698574803934567774824230985421074605062371141877954182153046474983581941267398767559165543946077062914571196477686542167660429831652624386837205668069376")
+
+    def test_repr(self):
+        v1, v2 = self.Integers(-1, 2**80)
+        self.assertEqual(repr(v1), "Integer(-1)")
+        self.assertEqual(repr(v2), "Integer(1208925819614629174706176)")
+
+    def test_conversion_to_bytes(self):
+        Integer = self.Integer
+
+        v0 = Integer(0)
+        self.assertEqual(b"\x00", v0.to_bytes())
+
+        v1 = Integer(0x17)
+        self.assertEqual(b"\x17", v1.to_bytes())
+
+        v2 = Integer(0xFFFE)
+        self.assertEqual(b"\xFF\xFE", v2.to_bytes())
+        self.assertEqual(b"\x00\xFF\xFE", v2.to_bytes(3))
+        self.assertRaises(ValueError, v2.to_bytes, 1)
+
+        self.assertEqual(b"\xFE\xFF", v2.to_bytes(byteorder='little'))
+        self.assertEqual(b"\xFE\xFF\x00", v2.to_bytes(3, byteorder='little'))
+
+        v3 = Integer(0xFF00AABBCCDDEE1122)
+        self.assertEqual(b"\xFF\x00\xAA\xBB\xCC\xDD\xEE\x11\x22", v3.to_bytes())
+        self.assertEqual(b"\x22\x11\xEE\xDD\xCC\xBB\xAA\x00\xFF",
+                         v3.to_bytes(byteorder='little'))
+        self.assertEqual(b"\x00\xFF\x00\xAA\xBB\xCC\xDD\xEE\x11\x22",
+                         v3.to_bytes(10))
+        self.assertEqual(b"\x22\x11\xEE\xDD\xCC\xBB\xAA\x00\xFF\x00",
+                         v3.to_bytes(10, byteorder='little'))
+        self.assertRaises(ValueError, v3.to_bytes, 8)
+
+        v4 = Integer(-90)
+        self.assertRaises(ValueError, v4.to_bytes)
+        self.assertRaises(ValueError, v4.to_bytes, byteorder='bittle')
+
+    def test_conversion_from_bytes(self):
+        Integer = self.Integer
+
+        v1 = Integer.from_bytes(b"\x00")
+        self.assertTrue(isinstance(v1, Integer))
+        self.assertEqual(0, v1)
+
+        v2 = Integer.from_bytes(b"\x00\x01")
+        self.assertEqual(1, v2)
+
+        v3 = Integer.from_bytes(b"\xFF\xFF")
+        self.assertEqual(0xFFFF, v3)
+
+        v4 = Integer.from_bytes(b"\x00\x01", 'big')
+        self.assertEqual(1, v4)
+
+        v5 = Integer.from_bytes(b"\x00\x01", byteorder='big')
+        self.assertEqual(1, v5)
+
+        v6 = Integer.from_bytes(b"\x00\x01", byteorder='little')
+        self.assertEqual(0x0100, v6)
+
+        self.assertRaises(ValueError, Integer.from_bytes, b'\x09', 'bittle')
+
+    def test_inequality(self):
+        # Test Integer!=Integer and Integer!=int
+        v1, v2, v3, v4 = self.Integers(89, 89, 90, -8)
+        self.assertTrue(v1 != v3)
+        self.assertTrue(v1 != 90)
+        self.assertFalse(v1 != v2)
+        self.assertFalse(v1 != 89)
+        self.assertTrue(v1 != v4)
+        self.assertTrue(v4 != v1)
+        self.assertTrue(self.Integer(0) != None)
+
+    def test_less_than(self):
+        # Test Integer<Integer and Integer<int
+        v1, v2, v3, v4, v5 = self.Integers(13, 13, 14, -8, 2 ** 10)
+        self.assertTrue(v1 < v3)
+        self.assertTrue(v1 < 14)
+        self.assertFalse(v1 < v2)
+        self.assertFalse(v1 < 13)
+        self.assertTrue(v4 < v1)
+        self.assertFalse(v1 < v4)
+        self.assertTrue(v1 < v5)
+        self.assertFalse(v5 < v1)
+
+    def test_less_than_or_equal(self):
+        # Test Integer<=Integer and Integer<=int
+        v1, v2, v3, v4, v5 = self.Integers(13, 13, 14, -4, 2 ** 10)
+        self.assertTrue(v1 <= v1)
+        self.assertTrue(v1 <= 13)
+        self.assertTrue(v1 <= v2)
+        self.assertTrue(v1 <= 14)
+        self.assertTrue(v1 <= v3)
+        self.assertFalse(v1 <= v4)
+        self.assertTrue(v1 <= v5)
+        self.assertFalse(v5 <= v1)
+
+    def test_more_than(self):
+        # Test Integer>Integer and Integer>int
+        v1, v2, v3, v4, v5 = self.Integers(13, 13, 14, -8, 2 ** 10)
+        self.assertTrue(v3 > v1)
+        self.assertTrue(v3 > 13)
+        self.assertFalse(v1 > v1)
+        self.assertFalse(v1 > v2)
+        self.assertFalse(v1 > 13)
+        self.assertTrue(v1 > v4)
+        self.assertFalse(v4 > v1)
+        self.assertTrue(v5 > v1)
+        self.assertFalse(v1 > v5)
+
+    def test_more_than_or_equal(self):
+        # Test Integer>=Integer and Integer>=int
+        v1, v2, v3, v4 = self.Integers(13, 13, 14, -4)
+        self.assertTrue(v3 >= v1)
+        self.assertTrue(v3 >= 13)
+        self.assertTrue(v1 >= v2)
+        self.assertTrue(v1 >= v1)
+        self.assertTrue(v1 >= 13)
+        self.assertFalse(v4 >= v1)
+
+    def test_bool(self):
+        v1, v2, v3, v4 = self.Integers(0, 10, -9, 2 ** 10)
+        self.assertFalse(v1)
+        self.assertFalse(bool(v1))
+        self.assertTrue(v2)
+        self.assertTrue(bool(v2))
+        self.assertTrue(v3)
+        self.assertTrue(v4)
+
+    def test_is_negative(self):
+        v1, v2, v3, v4, v5 = self.Integers(-3 ** 100, -3, 0, 3, 3**100)
+        self.assertTrue(v1.is_negative())
+        self.assertTrue(v2.is_negative())
+        self.assertFalse(v4.is_negative())
+        self.assertFalse(v5.is_negative())
+
+    def test_addition(self):
+        # Test Integer+Integer and Integer+int
+        v1, v2, v3 = self.Integers(7, 90, -7)
+        self.assertTrue(isinstance(v1 + v2, self.Integer))
+        self.assertEqual(v1 + v2, 97)
+        self.assertEqual(v1 + 90, 97)
+        self.assertEqual(v1 + v3, 0)
+        self.assertEqual(v1 + (-7), 0)
+        self.assertEqual(v1 + 2 ** 10, 2 ** 10 + 7)
+
+    def test_subtraction(self):
+        # Test Integer-Integer and Integer-int
+        v1, v2, v3 = self.Integers(7, 90, -7)
+        self.assertTrue(isinstance(v1 - v2, self.Integer))
+        self.assertEqual(v2 - v1, 83)
+        self.assertEqual(v2 - 7, 83)
+        self.assertEqual(v2 - v3, 97)
+        self.assertEqual(v1 - (-7), 14)
+        self.assertEqual(v1 - 2 ** 10, 7 - 2 ** 10)
+
+    def test_multiplication(self):
+        # Test Integer-Integer and Integer-int
+        v1, v2, v3, v4 = self.Integers(4, 5, -2, 2 ** 10)
+        self.assertTrue(isinstance(v1 * v2, self.Integer))
+        self.assertEqual(v1 * v2, 20)
+        self.assertEqual(v1 * 5, 20)
+        self.assertEqual(v1 * -2, -8)
+        self.assertEqual(v1 * 2 ** 10, 4 * (2 ** 10))
+
+    def test_floor_div(self):
+        v1, v2, v3 = self.Integers(3, 8, 2 ** 80)
+        self.assertTrue(isinstance(v1 // v2, self.Integer))
+        self.assertEqual(v2 // v1, 2)
+        self.assertEqual(v2 // 3, 2)
+        self.assertEqual(v2 // -3, -3)
+        self.assertEqual(v3 // 2 ** 79, 2)
+        self.assertRaises(ZeroDivisionError, lambda: v1 // 0)
+
+    def test_remainder(self):
+        # Test Integer%Integer and Integer%int
+        v1, v2, v3 = self.Integers(23, 5, -4)
+        self.assertTrue(isinstance(v1 % v2, self.Integer))
+        self.assertEqual(v1 % v2, 3)
+        self.assertEqual(v1 % 5, 3)
+        self.assertEqual(v3 % 5, 1)
+        self.assertEqual(v1 % 2 ** 10, 23)
+        self.assertRaises(ZeroDivisionError, lambda: v1 % 0)
+        self.assertRaises(ValueError, lambda: v1 % -6)
+
+    def test_simple_exponentiation(self):
+        v1, v2, v3 = self.Integers(4, 3, -2)
+        self.assertTrue(isinstance(v1 ** v2, self.Integer))
+        self.assertEqual(v1 ** v2, 64)
+        self.assertEqual(pow(v1, v2), 64)
+        self.assertEqual(v1 ** 3, 64)
+        self.assertEqual(pow(v1, 3), 64)
+        self.assertEqual(v3 ** 2, 4)
+        self.assertEqual(v3 ** 3, -8)
+
+        self.assertRaises(ValueError, pow, v1, -3)
+
+    def test_modular_exponentiation(self):
+        v1, v2, v3 = self.Integers(23, 5, 17)
+
+        self.assertTrue(isinstance(pow(v1, v2, v3), self.Integer))
+        self.assertEqual(pow(v1, v2, v3), 7)
+        self.assertEqual(pow(v1, 5,  v3), 7)
+        self.assertEqual(pow(v1, v2, 17), 7)
+        self.assertEqual(pow(v1, 5,  17), 7)
+        self.assertEqual(pow(v1, 0,  17), 1)
+        self.assertEqual(pow(v1, 1,  2 ** 80), 23)
+        self.assertEqual(pow(v1, 2 ** 80,  89298), 17689)
+
+        self.assertRaises(ZeroDivisionError, pow, v1, 5, 0)
+        self.assertRaises(ValueError, pow, v1, 5, -4)
+        self.assertRaises(ValueError, pow, v1, -3, 8)
+
+    def test_inplace_exponentiation(self):
+        v1 = self.Integer(4)
+        v1.inplace_pow(2)
+        self.assertEqual(v1, 16)
+
+        v1 = self.Integer(4)
+        v1.inplace_pow(2, 15)
+        self.assertEqual(v1, 1)
+
+    def test_abs(self):
+        v1, v2, v3, v4, v5 = self.Integers(-2 ** 100, -2, 0, 2, 2 ** 100)
+        self.assertEqual(abs(v1), 2 ** 100)
+        self.assertEqual(abs(v2), 2)
+        self.assertEqual(abs(v3), 0)
+        self.assertEqual(abs(v4), 2)
+        self.assertEqual(abs(v5), 2 ** 100)
+
+    def test_sqrt(self):
+        v1, v2, v3, v4 = self.Integers(-2, 0, 49, 10**100)
+
+        self.assertRaises(ValueError, v1.sqrt)
+        self.assertEqual(v2.sqrt(), 0)
+        self.assertEqual(v3.sqrt(), 7)
+        self.assertEqual(v4.sqrt(), 10**50)
+
+    def test_sqrt_module(self):
+
+        # Invalid modulus (non positive)
+        self.assertRaises(ValueError, self.Integer(5).sqrt, 0)
+        self.assertRaises(ValueError, self.Integer(5).sqrt, -1)
+
+        # Simple cases
+        assert self.Integer(0).sqrt(5) == 0
+        assert self.Integer(1).sqrt(5) in (1, 4)
+
+        # Test with all quadratic residues in several fields
+        for p in (11, 13, 17, 19, 23, 29, 31, 37, 41, 43, 47, 53):
+            for i in range(0, p):
+                square = i**2 % p
+                res = self.Integer(square).sqrt(p)
+                assert res in (i, p - i)
+
+        # 2 is a non-quadratic reside in Z_11
+        self.assertRaises(ValueError, self.Integer(2).sqrt, 11)
+
+        # 10 is not a prime
+        self.assertRaises(ValueError, self.Integer(4).sqrt, 10)
+
+        # 5 is square residue of 4 and 7
+        assert self.Integer(5 - 11).sqrt(11) in (4, 7)
+        assert self.Integer(5 + 11).sqrt(11) in (4, 7)
+
+    def test_in_place_add(self):
+        v1, v2 = self.Integers(10, 20)
+
+        v1 += v2
+        self.assertEqual(v1, 30)
+        v1 += 10
+        self.assertEqual(v1, 40)
+        v1 += -1
+        self.assertEqual(v1, 39)
+        v1 += 2 ** 1000
+        self.assertEqual(v1, 39 + 2 ** 1000)
+
+    def test_in_place_sub(self):
+        v1, v2 = self.Integers(10, 20)
+
+        v1 -= v2
+        self.assertEqual(v1, -10)
+        v1 -= -100
+        self.assertEqual(v1, 90)
+        v1 -= 90000
+        self.assertEqual(v1, -89910)
+        v1 -= -100000
+        self.assertEqual(v1, 10090)
+
+    def test_in_place_mul(self):
+        v1, v2 = self.Integers(3, 5)
+
+        v1 *= v2
+        self.assertEqual(v1, 15)
+        v1 *= 2
+        self.assertEqual(v1, 30)
+        v1 *= -2
+        self.assertEqual(v1, -60)
+        v1 *= 2 ** 1000
+        self.assertEqual(v1, -60 * (2 ** 1000))
+
+    def test_in_place_modulus(self):
+        v1, v2 = self.Integers(20, 7)
+
+        v1 %= v2
+        self.assertEqual(v1, 6)
+        v1 %= 2 ** 1000
+        self.assertEqual(v1, 6)
+        v1 %= 2
+        self.assertEqual(v1, 0)
+        def t():
+            v3 = self.Integer(9)
+            v3 %= 0
+        self.assertRaises(ZeroDivisionError, t)
+
+    def test_and(self):
+        v1, v2, v3 = self.Integers(0xF4, 0x31, -0xF)
+        self.assertTrue(isinstance(v1 & v2, self.Integer))
+        self.assertEqual(v1 & v2, 0x30)
+        self.assertEqual(v1 & 0x31, 0x30)
+        self.assertEqual(v1 & v3, 0xF0)
+        self.assertEqual(v1 & -0xF, 0xF0)
+        self.assertEqual(v3 & -0xF, -0xF)
+        self.assertEqual(v2 & (2 ** 1000 + 0x31), 0x31)
+
+    def test_or(self):
+        v1, v2, v3 = self.Integers(0x40, 0x82, -0xF)
+        self.assertTrue(isinstance(v1 | v2, self.Integer))
+        self.assertEqual(v1 | v2, 0xC2)
+        self.assertEqual(v1 | 0x82, 0xC2)
+        self.assertEqual(v2 | v3, -0xD)
+        self.assertEqual(v2 | 2 ** 1000, 2 ** 1000 + 0x82)
+
+    def test_right_shift(self):
+        v1, v2, v3 = self.Integers(0x10, 1, -0x10)
+        self.assertEqual(v1 >> 0, v1)
+        self.assertTrue(isinstance(v1 >> v2, self.Integer))
+        self.assertEqual(v1 >> v2, 0x08)
+        self.assertEqual(v1 >> 1, 0x08)
+        self.assertRaises(ValueError, lambda: v1 >> -1)
+        self.assertEqual(v1 >> (2 ** 1000), 0)
+
+        self.assertEqual(v3 >> 1, -0x08)
+        self.assertEqual(v3 >> (2 ** 1000), -1)
+
+    def test_in_place_right_shift(self):
+        v1, v2, v3 = self.Integers(0x10, 1, -0x10)
+        v1 >>= 0
+        self.assertEqual(v1, 0x10)
+        v1 >>= 1
+        self.assertEqual(v1, 0x08)
+        v1 >>= v2
+        self.assertEqual(v1, 0x04)
+        v3 >>= 1
+        self.assertEqual(v3, -0x08)
+        def l():
+            v4 = self.Integer(0x90)
+            v4 >>= -1
+        self.assertRaises(ValueError, l)
+        def m1():
+            v4 = self.Integer(0x90)
+            v4 >>= 2 ** 1000
+            return v4
+        self.assertEqual(0, m1())
+        def m2():
+            v4 = self.Integer(-1)
+            v4 >>= 2 ** 1000
+            return v4
+        self.assertEqual(-1, m2())
+
+    def _test_left_shift(self):
+        v1, v2, v3 = self.Integers(0x10, 1, -0x10)
+        self.assertEqual(v1 << 0, v1)
+        self.assertTrue(isinstance(v1 << v2, self.Integer))
+        self.assertEqual(v1 << v2, 0x20)
+        self.assertEqual(v1 << 1, 0x20)
+        self.assertEqual(v3 << 1, -0x20)
+        self.assertRaises(ValueError, lambda: v1 << -1)
+        self.assertRaises(ValueError, lambda: v1 << (2 ** 1000))
+
+    def test_in_place_left_shift(self):
+        v1, v2, v3 = self.Integers(0x10, 1, -0x10)
+        v1 <<= 0
+        self.assertEqual(v1, 0x10)
+        v1 <<= 1
+        self.assertEqual(v1, 0x20)
+        v1 <<= v2
+        self.assertEqual(v1, 0x40)
+        v3 <<= 1
+        self.assertEqual(v3, -0x20)
+        def l():
+            v4 = self.Integer(0x90)
+            v4 <<= -1
+        self.assertRaises(ValueError, l)
+        def m():
+            v4 = self.Integer(0x90)
+            v4 <<= 2 ** 1000
+        self.assertRaises(ValueError, m)
+
+
+    def test_get_bit(self):
+        v1, v2, v3 = self.Integers(0x102, -3, 1)
+        self.assertEqual(v1.get_bit(0), 0)
+        self.assertEqual(v1.get_bit(1), 1)
+        self.assertEqual(v1.get_bit(v3), 1)
+        self.assertEqual(v1.get_bit(8), 1)
+        self.assertEqual(v1.get_bit(9), 0)
+
+        self.assertRaises(ValueError, v1.get_bit, -1)
+        self.assertEqual(v1.get_bit(2 ** 1000), 0)
+
+        self.assertRaises(ValueError, v2.get_bit, -1)
+        self.assertRaises(ValueError, v2.get_bit, 0)
+        self.assertRaises(ValueError, v2.get_bit, 1)
+        self.assertRaises(ValueError, v2.get_bit, 2 * 1000)
+
+    def test_odd_even(self):
+        v1, v2, v3, v4, v5 = self.Integers(0, 4, 17, -4, -17)
+
+        self.assertTrue(v1.is_even())
+        self.assertTrue(v2.is_even())
+        self.assertFalse(v3.is_even())
+        self.assertTrue(v4.is_even())
+        self.assertFalse(v5.is_even())
+
+        self.assertFalse(v1.is_odd())
+        self.assertFalse(v2.is_odd())
+        self.assertTrue(v3.is_odd())
+        self.assertFalse(v4.is_odd())
+        self.assertTrue(v5.is_odd())
+
+    def test_size_in_bits(self):
+        v1, v2, v3, v4 = self.Integers(0, 1, 0x100, -90)
+        self.assertEqual(v1.size_in_bits(), 1)
+        self.assertEqual(v2.size_in_bits(), 1)
+        self.assertEqual(v3.size_in_bits(), 9)
+        self.assertRaises(ValueError, v4.size_in_bits)
+
+    def test_size_in_bytes(self):
+        v1, v2, v3, v4, v5, v6 = self.Integers(0, 1, 0xFF, 0x1FF, 0x10000, -9)
+        self.assertEqual(v1.size_in_bytes(), 1)
+        self.assertEqual(v2.size_in_bytes(), 1)
+        self.assertEqual(v3.size_in_bytes(), 1)
+        self.assertEqual(v4.size_in_bytes(), 2)
+        self.assertEqual(v5.size_in_bytes(), 3)
+        self.assertRaises(ValueError, v6.size_in_bits)
+
+    def test_perfect_square(self):
+
+        self.assertFalse(self.Integer(-9).is_perfect_square())
+        self.assertTrue(self.Integer(0).is_perfect_square())
+        self.assertTrue(self.Integer(1).is_perfect_square())
+        self.assertFalse(self.Integer(2).is_perfect_square())
+        self.assertFalse(self.Integer(3).is_perfect_square())
+        self.assertTrue(self.Integer(4).is_perfect_square())
+        self.assertTrue(self.Integer(39*39).is_perfect_square())
+        self.assertFalse(self.Integer(39*39+1).is_perfect_square())
+
+        for x in range(100, 1000):
+            self.assertFalse(self.Integer(x**2+1).is_perfect_square())
+            self.assertTrue(self.Integer(x**2).is_perfect_square())
+
+    def test_fail_if_divisible_by(self):
+        v1, v2, v3 = self.Integers(12, -12, 4)
+
+        # No failure expected
+        v1.fail_if_divisible_by(7)
+        v2.fail_if_divisible_by(7)
+        v2.fail_if_divisible_by(2 ** 80)
+
+        # Failure expected
+        self.assertRaises(ValueError, v1.fail_if_divisible_by, 4)
+        self.assertRaises(ValueError, v1.fail_if_divisible_by, v3)
+
+    def test_multiply_accumulate(self):
+        v1, v2, v3 = self.Integers(4, 3, 2)
+        v1.multiply_accumulate(v2, v3)
+        self.assertEqual(v1, 10)
+        v1.multiply_accumulate(v2, 2)
+        self.assertEqual(v1, 16)
+        v1.multiply_accumulate(3, v3)
+        self.assertEqual(v1, 22)
+        v1.multiply_accumulate(1, -2)
+        self.assertEqual(v1, 20)
+        v1.multiply_accumulate(-2, 1)
+        self.assertEqual(v1, 18)
+        v1.multiply_accumulate(1, 2 ** 1000)
+        self.assertEqual(v1, 18 + 2 ** 1000)
+        v1.multiply_accumulate(2 ** 1000, 1)
+        self.assertEqual(v1, 18 + 2 ** 1001)
+
+    def test_set(self):
+        v1, v2 = self.Integers(3, 6)
+        v1.set(v2)
+        self.assertEqual(v1, 6)
+        v1.set(9)
+        self.assertEqual(v1, 9)
+        v1.set(-2)
+        self.assertEqual(v1, -2)
+        v1.set(2 ** 1000)
+        self.assertEqual(v1, 2 ** 1000)
+
+    def test_inverse(self):
+        v1, v2, v3, v4, v5, v6 = self.Integers(2, 5, -3, 0, 723872, 3433)
+
+        self.assertTrue(isinstance(v1.inverse(v2), self.Integer))
+        self.assertEqual(v1.inverse(v2), 3)
+        self.assertEqual(v1.inverse(5), 3)
+        self.assertEqual(v3.inverse(5), 3)
+        self.assertEqual(v5.inverse(92929921), 58610507)
+        self.assertEqual(v6.inverse(9912), 5353)
+
+        self.assertRaises(ValueError, v2.inverse, 10)
+        self.assertRaises(ValueError, v1.inverse, -3)
+        self.assertRaises(ValueError, v4.inverse, 10)
+        self.assertRaises(ZeroDivisionError, v2.inverse, 0)
+
+    def test_inplace_inverse(self):
+        v1, v2 = self.Integers(2, 5)
+
+        v1.inplace_inverse(v2)
+        self.assertEqual(v1, 3)
+
+    def test_gcd(self):
+        v1, v2, v3, v4 = self.Integers(6, 10, 17, -2)
+        self.assertTrue(isinstance(v1.gcd(v2), self.Integer))
+        self.assertEqual(v1.gcd(v2), 2)
+        self.assertEqual(v1.gcd(10), 2)
+        self.assertEqual(v1.gcd(v3), 1)
+        self.assertEqual(v1.gcd(-2), 2)
+        self.assertEqual(v4.gcd(6), 2)
+
+    def test_lcm(self):
+        v1, v2, v3, v4, v5 = self.Integers(6, 10, 17, -2, 0)
+        self.assertTrue(isinstance(v1.lcm(v2), self.Integer))
+        self.assertEqual(v1.lcm(v2), 30)
+        self.assertEqual(v1.lcm(10), 30)
+        self.assertEqual(v1.lcm(v3), 102)
+        self.assertEqual(v1.lcm(-2), 6)
+        self.assertEqual(v4.lcm(6), 6)
+        self.assertEqual(v1.lcm(0), 0)
+        self.assertEqual(v5.lcm(0), 0)
+
+    def test_jacobi_symbol(self):
+
+        data = (
+            (1001, 1, 1),
+            (19, 45, 1),
+            (8, 21, -1),
+            (5, 21, 1),
+            (610, 987, -1),
+            (1001, 9907, -1),
+            (5, 3439601197, -1)
+            )
+
+        js = self.Integer.jacobi_symbol
+
+        # Jacobi symbol is always 1 for k==1 or n==1
+        for k in range(1, 30):
+            self.assertEqual(js(k, 1), 1)
+        for n in range(1, 30, 2):
+            self.assertEqual(js(1, n), 1)
+
+        # Fail if n is not positive odd
+        self.assertRaises(ValueError, js, 6, -2)
+        self.assertRaises(ValueError, js, 6, -1)
+        self.assertRaises(ValueError, js, 6, 0)
+        self.assertRaises(ValueError, js, 0, 0)
+        self.assertRaises(ValueError, js, 6, 2)
+        self.assertRaises(ValueError, js, 6, 4)
+        self.assertRaises(ValueError, js, 6, 6)
+        self.assertRaises(ValueError, js, 6, 8)
+
+        for tv in data:
+            self.assertEqual(js(tv[0], tv[1]), tv[2])
+            self.assertEqual(js(self.Integer(tv[0]), tv[1]), tv[2])
+            self.assertEqual(js(tv[0], self.Integer(tv[1])), tv[2])
+
+    def test_jacobi_symbol_wikipedia(self):
+
+		# Test vectors from https://en.wikipedia.org/wiki/Jacobi_symbol
+        tv = [
+            (3, [(1, 1), (2, -1), (3, 0), (4, 1), (5, -1), (6, 0), (7, 1), (8, -1), (9, 0), (10, 1), (11, -1), (12, 0), (13, 1), (14, -1), (15, 0), (16, 1), (17, -1), (18, 0), (19, 1), (20, -1), (21, 0), (22, 1), (23, -1), (24, 0), (25, 1), (26, -1), (27, 0), (28, 1), (29, -1), (30, 0)]),
+            (5, [(1, 1), (2, -1), (3, -1), (4, 1), (5, 0), (6, 1), (7, -1), (8, -1), (9, 1), (10, 0), (11, 1), (12, -1), (13, -1), (14, 1), (15, 0), (16, 1), (17, -1), (18, -1), (19, 1), (20, 0), (21, 1), (22, -1), (23, -1), (24, 1), (25, 0), (26, 1), (27, -1), (28, -1), (29, 1), (30, 0)]),
+            (7, [(1, 1), (2, 1), (3, -1), (4, 1), (5, -1), (6, -1), (7, 0), (8, 1), (9, 1), (10, -1), (11, 1), (12, -1), (13, -1), (14, 0), (15, 1), (16, 1), (17, -1), (18, 1), (19, -1), (20, -1), (21, 0), (22, 1), (23, 1), (24, -1), (25, 1), (26, -1), (27, -1), (28, 0), (29, 1), (30, 1)]),
+            (9, [(1, 1), (2, 1), (3, 0), (4, 1), (5, 1), (6, 0), (7, 1), (8, 1), (9, 0), (10, 1), (11, 1), (12, 0), (13, 1), (14, 1), (15, 0), (16, 1), (17, 1), (18, 0), (19, 1), (20, 1), (21, 0), (22, 1), (23, 1), (24, 0), (25, 1), (26, 1), (27, 0), (28, 1), (29, 1), (30, 0)]),
+            (11, [(1, 1), (2, -1), (3, 1), (4, 1), (5, 1), (6, -1), (7, -1), (8, -1), (9, 1), (10, -1), (11, 0), (12, 1), (13, -1), (14, 1), (15, 1), (16, 1), (17, -1), (18, -1), (19, -1), (20, 1), (21, -1), (22, 0), (23, 1), (24, -1), (25, 1), (26, 1), (27, 1), (28, -1), (29, -1), (30, -1)]),
+            (13, [(1, 1), (2, -1), (3, 1), (4, 1), (5, -1), (6, -1), (7, -1), (8, -1), (9, 1), (10, 1), (11, -1), (12, 1), (13, 0), (14, 1), (15, -1), (16, 1), (17, 1), (18, -1), (19, -1), (20, -1), (21, -1), (22, 1), (23, 1), (24, -1), (25, 1), (26, 0), (27, 1), (28, -1), (29, 1), (30, 1)]),
+            (15, [(1, 1), (2, 1), (3, 0), (4, 1), (5, 0), (6, 0), (7, -1), (8, 1), (9, 0), (10, 0), (11, -1), (12, 0), (13, -1), (14, -1), (15, 0), (16, 1), (17, 1), (18, 0), (19, 1), (20, 0), (21, 0), (22, -1), (23, 1), (24, 0), (25, 0), (26, -1), (27, 0), (28, -1), (29, -1), (30, 0)]),
+            (17, [(1, 1), (2, 1), (3, -1), (4, 1), (5, -1), (6, -1), (7, -1), (8, 1), (9, 1), (10, -1), (11, -1), (12, -1), (13, 1), (14, -1), (15, 1), (16, 1), (17, 0), (18, 1), (19, 1), (20, -1), (21, 1), (22, -1), (23, -1), (24, -1), (25, 1), (26, 1), (27, -1), (28, -1), (29, -1), (30, 1)]),
+            (19, [(1, 1), (2, -1), (3, -1), (4, 1), (5, 1), (6, 1), (7, 1), (8, -1), (9, 1), (10, -1), (11, 1), (12, -1), (13, -1), (14, -1), (15, -1), (16, 1), (17, 1), (18, -1), (19, 0), (20, 1), (21, -1), (22, -1), (23, 1), (24, 1), (25, 1), (26, 1), (27, -1), (28, 1), (29, -1), (30, 1)]),
+            (21, [(1, 1), (2, -1), (3, 0), (4, 1), (5, 1), (6, 0), (7, 0), (8, -1), (9, 0), (10, -1), (11, -1), (12, 0), (13, -1), (14, 0), (15, 0), (16, 1), (17, 1), (18, 0), (19, -1), (20, 1), (21, 0), (22, 1), (23, -1), (24, 0), (25, 1), (26, 1), (27, 0), (28, 0), (29, -1), (30, 0)]),
+            (23, [(1, 1), (2, 1), (3, 1), (4, 1), (5, -1), (6, 1), (7, -1), (8, 1), (9, 1), (10, -1), (11, -1), (12, 1), (13, 1), (14, -1), (15, -1), (16, 1), (17, -1), (18, 1), (19, -1), (20, -1), (21, -1), (22, -1), (23, 0), (24, 1), (25, 1), (26, 1), (27, 1), (28, -1), (29, 1), (30, -1)]),
+            (25, [(1, 1), (2, 1), (3, 1), (4, 1), (5, 0), (6, 1), (7, 1), (8, 1), (9, 1), (10, 0), (11, 1), (12, 1), (13, 1), (14, 1), (15, 0), (16, 1), (17, 1), (18, 1), (19, 1), (20, 0), (21, 1), (22, 1), (23, 1), (24, 1), (25, 0), (26, 1), (27, 1), (28, 1), (29, 1), (30, 0)]),
+            (27, [(1, 1), (2, -1), (3, 0), (4, 1), (5, -1), (6, 0), (7, 1), (8, -1), (9, 0), (10, 1), (11, -1), (12, 0), (13, 1), (14, -1), (15, 0), (16, 1), (17, -1), (18, 0), (19, 1), (20, -1), (21, 0), (22, 1), (23, -1), (24, 0), (25, 1), (26, -1), (27, 0), (28, 1), (29, -1), (30, 0)]),
+            (29, [(1, 1), (2, -1), (3, -1), (4, 1), (5, 1), (6, 1), (7, 1), (8, -1), (9, 1), (10, -1), (11, -1), (12, -1), (13, 1), (14, -1), (15, -1), (16, 1), (17, -1), (18, -1), (19, -1), (20, 1), (21, -1), (22, 1), (23, 1), (24, 1), (25, 1), (26, -1), (27, -1), (28, 1), (29, 0), (30, 1)]),
+            ]
+
+        js = self.Integer.jacobi_symbol
+
+        for n, kj in tv:
+            for k, j in kj:
+                self.assertEqual(js(k, n), j)
+
+    def test_hex(self):
+        v1, = self.Integers(0x10)
+        self.assertEqual(hex(v1), "0x10")
+
+    def test_mult_modulo_bytes(self):
+        modmult = self.Integer._mult_modulo_bytes
+
+        res = modmult(4, 5, 19)
+        self.assertEqual(res, b'\x01')
+
+        res = modmult(4 - 19, 5, 19)
+        self.assertEqual(res, b'\x01')
+
+        res = modmult(4, 5 - 19, 19)
+        self.assertEqual(res, b'\x01')
+
+        res = modmult(4 + 19, 5, 19)
+        self.assertEqual(res, b'\x01')
+
+        res = modmult(4, 5 + 19, 19)
+        self.assertEqual(res, b'\x01')
+
+        modulus = 2**512 - 1    # 64 bytes
+        t1 = 13**100
+        t2 = 17**100
+        expect = b"\xfa\xb2\x11\x87\xc3(y\x07\xf8\xf1n\xdepq\x0b\xca\xf3\xd3B,\xef\xf2\xfbf\xcc)\x8dZ*\x95\x98r\x96\xa8\xd5\xc3}\xe2q:\xa2'z\xf48\xde%\xef\t\x07\xbc\xc4[C\x8bUE2\x90\xef\x81\xaa:\x08"
+        self.assertEqual(expect, modmult(t1, t2, modulus))
+
+        self.assertRaises(ZeroDivisionError, modmult, 4, 5, 0)
+        self.assertRaises(ValueError, modmult, 4, 5, -1)
+        self.assertRaises(ValueError, modmult, 4, 5, 4)
+
+
+class TestIntegerInt(TestIntegerBase):
+
+    def setUp(self):
+        self.Integer = IntegerNative
+
+
+class testIntegerRandom(unittest.TestCase):
+
+    def test_random_exact_bits(self):
+
+        for _ in range(1000):
+            a = IntegerNative.random(exact_bits=8)
+            self.assertFalse(a < 128)
+            self.assertFalse(a >= 256)
+
+        for bits_value in range(1024, 1024 + 8):
+            a = IntegerNative.random(exact_bits=bits_value)
+            self.assertFalse(a < 2**(bits_value - 1))
+            self.assertFalse(a >= 2**bits_value)
+
+    def test_random_max_bits(self):
+
+        flag = False
+        for _ in range(1000):
+            a = IntegerNative.random(max_bits=8)
+            flag = flag or a < 128
+            self.assertFalse(a>=256)
+        self.assertTrue(flag)
+
+        for bits_value in range(1024, 1024 + 8):
+            a = IntegerNative.random(max_bits=bits_value)
+            self.assertFalse(a >= 2**bits_value)
+
+    def test_random_bits_custom_rng(self):
+
+        class CustomRNG(object):
+            def __init__(self):
+                self.counter = 0
+
+            def __call__(self, size):
+                self.counter += size
+                return bchr(0) * size
+
+        custom_rng = CustomRNG()
+        a = IntegerNative.random(exact_bits=32, randfunc=custom_rng)
+        self.assertEqual(custom_rng.counter, 4)
+
+    def test_random_range(self):
+
+        func = IntegerNative.random_range
+
+        for x in range(200):
+            a = func(min_inclusive=1, max_inclusive=15)
+            self.assertTrue(1 <= a <= 15)
+
+        for x in range(200):
+            a = func(min_inclusive=1, max_exclusive=15)
+            self.assertTrue(1 <= a < 15)
+
+        self.assertRaises(ValueError, func, min_inclusive=1, max_inclusive=2,
+                                            max_exclusive=3)
+        self.assertRaises(ValueError, func, max_inclusive=2, max_exclusive=3)
+
+def get_tests(config={}):
+    tests = []
+    tests += list_test_cases(TestIntegerInt)
+
+    try:
+        from Crypto.Math._IntegerGMP import IntegerGMP
+
+        class TestIntegerGMP(TestIntegerBase):
+            def setUp(self):
+                self.Integer = IntegerGMP
+
+        tests += list_test_cases(TestIntegerGMP)
+    except (ImportError, OSError) as e:
+        if sys.platform == "win32":
+            sys.stdout.write("Skipping GMP tests on Windows\n")
+        else:
+            sys.stdout.write("Skipping GMP tests (%s)\n" % str(e) )
+
+    try:
+        from Crypto.Math._IntegerCustom import IntegerCustom
+
+        class TestIntegerCustomModexp(TestIntegerBase):
+            def setUp(self):
+                self.Integer = IntegerCustom
+
+        tests += list_test_cases(TestIntegerCustomModexp)
+    except (ImportError, OSError) as e:
+        sys.stdout.write("Skipping custom modexp tests (%s)\n" % str(e) )
+
+    tests += list_test_cases(testIntegerRandom)
+    return tests
+
+if __name__ == '__main__':
+    suite = lambda: unittest.TestSuite(get_tests())
+    unittest.main(defaultTest='suite')

minigpt2/lib/python3.10/site-packages/Crypto/SelfTest/Math/test_Primality.py

@@ -0,0 +1,118 @@
+#
+#  SelfTest/Math/test_Primality.py: Self-test for Primality module
+#
+# ===================================================================
+#
+# Copyright (c) 2014, Legrandin <helderijs@gmail.com>
+# All rights reserved.
+#
+# Redistribution and use in source and binary forms, with or without
+# modification, are permitted provided that the following conditions
+# are met:
+#
+# 1. Redistributions of source code must retain the above copyright
+#    notice, this list of conditions and the following disclaimer.
+# 2. Redistributions in binary form must reproduce the above copyright
+#    notice, this list of conditions and the following disclaimer in
+#    the documentation and/or other materials provided with the
+#    distribution.
+#
+# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+# "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+# LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
+# FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
+# COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
+# INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
+# BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+# LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+# CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+# LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
+# ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+# POSSIBILITY OF SUCH DAMAGE.
+# ===================================================================
+
+"""Self-test for Math.Numbers"""
+
+import unittest
+
+from Crypto.SelfTest.st_common import list_test_cases
+
+from Crypto.Util.py3compat import *
+
+from Crypto.Math.Numbers import Integer
+from Crypto.Math.Primality import (
+        PROBABLY_PRIME, COMPOSITE,
+        miller_rabin_test, lucas_test,
+        test_probable_prime,
+        generate_probable_prime,
+        generate_probable_safe_prime,
+        )
+
+
+class TestPrimality(unittest.TestCase):
+
+    primes = (1, 2, 3, 5, 7, 11, 13, 17, 19, 23, 2**127-1, 175637383534939453397801320455508570374088202376942372758907369518414308188137781042871856139027160010343454418881888953150175357127346872102307696660678617989191485418582475696230580407111841072614783095326672517315988762029036079794994990250662362650625650262324085116467511357592728695033227611029693067539)
+    composites = (0, 4, 6, 8, 9, 10, 12, 14, 15, 16, 18, 20, 21, 7*23, (2**19-1)*(2**67-1), 9746347772161,)
+
+    def test_miller_rabin(self):
+        for prime in self.primes:
+            self.assertEqual(miller_rabin_test(prime, 3), PROBABLY_PRIME)
+        for composite in self.composites:
+            self.assertEqual(miller_rabin_test(composite, 3), COMPOSITE)
+        self.assertRaises(ValueError, miller_rabin_test, -1, 3)
+
+    def test_lucas(self):
+        for prime in self.primes:
+            res = lucas_test(prime)
+            self.assertEqual(res, PROBABLY_PRIME)
+        for composite in self.composites:
+            res = lucas_test(composite)
+            self.assertEqual(res, COMPOSITE)
+        self.assertRaises(ValueError, lucas_test, -1)
+
+    def test_is_prime(self):
+        primes = (170141183460469231731687303715884105727,
+                  19175002942688032928599,
+                  1363005552434666078217421284621279933627102780881053358473,
+                  2 ** 521 - 1)
+        for p in primes:
+            self.assertEqual(test_probable_prime(p), PROBABLY_PRIME)
+
+        not_primes = (
+                    4754868377601046732119933839981363081972014948522510826417784001,
+                    1334733877147062382486934807105197899496002201113849920496510541601,
+                    260849323075371835669784094383812120359260783810157225730623388382401,
+                    )
+        for np in not_primes:
+            self.assertEqual(test_probable_prime(np), COMPOSITE)
+
+        from Crypto.Util.number import sieve_base
+        for p in sieve_base[:100]:
+            res = test_probable_prime(p)
+            self.assertEqual(res, PROBABLY_PRIME)
+
+    def test_generate_prime_bit_size(self):
+        p = generate_probable_prime(exact_bits=512)
+        self.assertEqual(p.size_in_bits(), 512)
+
+    def test_generate_prime_filter(self):
+        def ending_with_one(number):
+            return number % 10 == 1
+
+        for x in range(20):
+            q = generate_probable_prime(exact_bits=160,
+                    prime_filter=ending_with_one)
+            self.assertEqual(q % 10, 1)
+
+    def test_generate_safe_prime(self):
+        p = generate_probable_safe_prime(exact_bits=161)
+        self.assertEqual(p.size_in_bits(), 161)
+
+def get_tests(config={}):
+    tests = []
+    tests += list_test_cases(TestPrimality)
+    return tests
+
+if __name__ == '__main__':
+    suite = lambda: unittest.TestSuite(get_tests())
+    unittest.main(defaultTest='suite')

minigpt2/lib/python3.10/site-packages/Crypto/SelfTest/Math/test_modexp.py

@@ -0,0 +1,201 @@
+#
+#  SelfTest/Math/test_modexp.py: Self-test for module exponentiation
+#
+# ===================================================================
+#
+# Copyright (c) 2017, Helder Eijs <helderijs@gmail.com>
+# All rights reserved.
+#
+# Redistribution and use in source and binary forms, with or without
+# modification, are permitted provided that the following conditions
+# are met:
+#
+# 1. Redistributions of source code must retain the above copyright
+#    notice, this list of conditions and the following disclaimer.
+# 2. Redistributions in binary form must reproduce the above copyright
+#    notice, this list of conditions and the following disclaimer in
+#    the documentation and/or other materials provided with the
+#    distribution.
+#
+# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+# "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+# LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
+# FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
+# COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
+# INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
+# BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+# LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+# CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+# LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
+# ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+# POSSIBILITY OF SUCH DAMAGE.
+# ===================================================================
+
+"""Self-test for the custom module exponentiation"""
+
+import unittest
+
+from Crypto.SelfTest.st_common import list_test_cases
+
+from Crypto.Util.number import long_to_bytes, bytes_to_long
+
+from Crypto.Util.py3compat import *
+
+from Crypto.Util._raw_api import (load_pycryptodome_raw_lib,
+                                  create_string_buffer,
+                                  get_raw_buffer,
+                                  c_size_t,
+                                  c_ulonglong)
+
+from Crypto.Hash import SHAKE128
+from Crypto.Math.Numbers import Integer
+from Crypto.Math._IntegerCustom import _raw_montgomery
+
+from Crypto.Random.random import StrongRandom
+
+
+def create_rng(tag):
+    rng = StrongRandom(SHAKE128.new(data=tag))
+    return rng
+
+class ExceptionModulus(ValueError):
+    pass
+
+def monty_pow(base, exp, modulus):
+    max_len = len(long_to_bytes(max(base, exp, modulus)))
+
+    base_b, exp_b, modulus_b = [ long_to_bytes(x, max_len) for x in
+                                 (base, exp, modulus) ]
+
+    out = create_string_buffer(max_len)
+    error = _raw_montgomery.monty_pow(
+                out,
+                base_b,
+                exp_b,
+                modulus_b,
+                c_size_t(max_len),
+                c_ulonglong(32)
+                )
+
+    if error == 17:
+        raise ExceptionModulus()
+    if error:
+        raise ValueError("monty_pow failed with error: %d" % error)
+
+    result = bytes_to_long(get_raw_buffer(out))
+    return result
+
+exponent1 = 0x2ce0af628901460a419a08ef950d498b9fd6f271a1a52ac293b86fe5c60efe8e8ba93fa1ebe1eb3d614d2e7b328cb60a2591440e163441a190ecf101ceec245f600fffdcf3f5b3a17a7baeacb96a424db1d7ec985e8ec998bb479fecfffed6a75f9a90fc97062fd973303bce855ad7b8d8272a94025e8532be9aabd54a183f303538d2a7e621b4131d59e823a4625f39bd7d518d7784f7c3a8f19061da74974ff42fa1c063dec2db97d461e291a7d6e721708a5229de166c1246363372854e27f3f08ae274bc16bfd205b028a4d81386494433d516dfbb35f495acba5e4e1d1843cb3c3129b6642a85fc7244ce5845fac071c7f622e4ee12ac43fabeeaa0cd01
+modulus1 = 0xd66691b20071be4d66d4b71032b37fa007cfabf579fcb91e50bfc2753b3f0ce7be74e216aef7e26d4ae180bc20d7bd3ea88a6cbf6f87380e613c8979b5b043b200a8ff8856a3b12875e36e98a7569f3852d028e967551000b02c19e9fa52e83115b89309aabb1e1cf1e2cb6369d637d46775ce4523ea31f64ad2794cbc365dd8a35e007ed3b57695877fbf102dbeb8b3212491398e494314e93726926e1383f8abb5889bea954eb8c0ca1c62c8e9d83f41888095c5e645ed6d32515fe0c58c1368cad84694e18da43668c6f43e61d7c9bca633ddcda7aef5b79bc396d4a9f48e2a9abe0836cc455e435305357228e93d25aaed46b952defae0f57339bf26f5a9
+
+
+class TestModExp(unittest.TestCase):
+
+    def test_small(self):
+        self.assertEqual(1, monty_pow(11,12,19))
+
+    def test_large_1(self):
+        base = 0xfffffffffffffffffffffffffffffffffffffffffffffffffff
+        expected = pow(base, exponent1, modulus1)
+        result = monty_pow(base, exponent1, modulus1)
+        self.assertEqual(result, expected)
+
+    def test_zero_exp(self):
+        base = 0xfffffffffffffffffffffffffffffffffffffffffffffffffff
+        result = monty_pow(base, 0, modulus1)
+        self.assertEqual(result, 1)
+
+    def test_zero_base(self):
+        result = monty_pow(0, exponent1, modulus1)
+        self.assertEqual(result, 0)
+
+    def test_zero_modulus(self):
+        base = 0xfffffffffffffffffffffffffffffffffffffffffffffffff
+        self.assertRaises(ExceptionModulus, monty_pow, base, exponent1, 0)
+        self.assertRaises(ExceptionModulus, monty_pow, 0, 0, 0)
+
+    def test_larger_exponent(self):
+        base = modulus1 - 0xFFFFFFF
+        expected = pow(base, modulus1<<64, modulus1)
+        result = monty_pow(base, modulus1<<64, modulus1)
+        self.assertEqual(result, expected)
+
+    def test_even_modulus(self):
+        base = modulus1 >> 4
+        self.assertRaises(ExceptionModulus, monty_pow, base, exponent1, modulus1-1)
+
+    def test_several_lengths(self):
+        prng = SHAKE128.new().update(b('Test'))
+        for length in range(1, 100):
+            modulus2 = Integer.from_bytes(prng.read(length)) | 1
+            base = Integer.from_bytes(prng.read(length)) % modulus2
+            exponent2 = Integer.from_bytes(prng.read(length))
+
+            expected = pow(base, exponent2, modulus2)
+            result = monty_pow(base, exponent2, modulus2)
+            self.assertEqual(result, expected)
+
+    def test_variable_exponent(self):
+        prng = create_rng(b('Test variable exponent'))
+        for i in range(20):
+            for j in range(7):
+                modulus = prng.getrandbits(8*30) | 1
+                base = prng.getrandbits(8*30) % modulus
+                exponent = prng.getrandbits(i*8+j)
+
+                expected = pow(base, exponent, modulus)
+                result = monty_pow(base, exponent, modulus)
+                self.assertEqual(result, expected)
+
+                exponent ^= (1 << (i*8+j)) - 1
+
+                expected = pow(base, exponent, modulus)
+                result = monty_pow(base, exponent, modulus)
+                self.assertEqual(result, expected)
+
+    def test_stress_63(self):
+        prng = create_rng(b('Test 63'))
+        length = 63
+        for _ in range(2000):
+            modulus  = prng.getrandbits(8*length) | 1
+            base     = prng.getrandbits(8*length) % modulus
+            exponent = prng.getrandbits(8*length)
+
+            expected = pow(base, exponent, modulus)
+            result = monty_pow(base, exponent, modulus)
+            self.assertEqual(result, expected)
+
+    def test_stress_64(self):
+        prng = create_rng(b('Test 64'))
+        length = 64
+        for _ in range(2000):
+            modulus  = prng.getrandbits(8*length) | 1
+            base     = prng.getrandbits(8*length) % modulus
+            exponent = prng.getrandbits(8*length)
+
+            expected = pow(base, exponent, modulus)
+            result = monty_pow(base, exponent, modulus)
+            self.assertEqual(result, expected)
+
+    def test_stress_65(self):
+        prng = create_rng(b('Test 65'))
+        length = 65
+        for _ in range(2000):
+            modulus  = prng.getrandbits(8*length) | 1
+            base     = prng.getrandbits(8*length) % modulus
+            exponent = prng.getrandbits(8*length)
+
+            expected = pow(base, exponent, modulus)
+            result = monty_pow(base, exponent, modulus)
+            self.assertEqual(result, expected)
+
+
+def get_tests(config={}):
+    tests = []
+    tests += list_test_cases(TestModExp)
+    return tests
+
+
+if __name__ == '__main__':
+    suite = lambda: unittest.TestSuite(get_tests())
+    unittest.main(defaultTest='suite')

minigpt2/lib/python3.10/site-packages/Crypto/SelfTest/Math/test_modmult.py

@@ -0,0 +1,120 @@
+#
+#  SelfTest/Math/test_modmult.py: Self-test for custom modular multiplication
+#
+# ===================================================================
+#
+# Copyright (c) 2023, Helder Eijs <helderijs@gmail.com>
+# All rights reserved.
+#
+# Redistribution and use in source and binary forms, with or without
+# modification, are permitted provided that the following conditions
+# are met:
+#
+# 1. Redistributions of source code must retain the above copyright
+#    notice, this list of conditions and the following disclaimer.
+# 2. Redistributions in binary form must reproduce the above copyright
+#    notice, this list of conditions and the following disclaimer in
+#    the documentation and/or other materials provided with the
+#    distribution.
+#
+# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+# "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+# LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
+# FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
+# COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
+# INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
+# BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+# LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+# CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+# LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
+# ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+# POSSIBILITY OF SUCH DAMAGE.
+# ===================================================================
+
+"""Self-test for the custom modular multiplication"""
+
+import unittest
+
+from Crypto.SelfTest.st_common import list_test_cases
+
+from Crypto.Util.number import long_to_bytes, bytes_to_long
+
+from Crypto.Util._raw_api import (create_string_buffer,
+                                  get_raw_buffer,
+                                  c_size_t)
+
+from Crypto.Math._IntegerCustom import _raw_montgomery
+
+
+class ExceptionModulus(ValueError):
+    pass
+
+
+def monty_mult(term1, term2, modulus):
+
+    if term1 >= modulus:
+        term1 %= modulus
+    if term2 >= modulus:
+        term2 %= modulus
+
+    modulus_b = long_to_bytes(modulus)
+    numbers_len = len(modulus_b)
+    term1_b = long_to_bytes(term1, numbers_len)
+    term2_b = long_to_bytes(term2, numbers_len)
+
+    out = create_string_buffer(numbers_len)
+    error = _raw_montgomery.monty_multiply(
+                out,
+                term1_b,
+                term2_b,
+                modulus_b,
+                c_size_t(numbers_len)
+                )
+
+    if error == 17:
+        raise ExceptionModulus()
+    if error:
+        raise ValueError("monty_multiply() failed with error: %d" % error)
+
+    return get_raw_buffer(out)
+
+
+modulus1 = 0xd66691b20071be4d66d4b71032b37fa007cfabf579fcb91e50bfc2753b3f0ce7be74e216aef7e26d4ae180bc20d7bd3ea88a6cbf6f87380e613c8979b5b043b200a8ff8856a3b12875e36e98a7569f3852d028e967551000b02c19e9fa52e83115b89309aabb1e1cf1e2cb6369d637d46775ce4523ea31f64ad2794cbc365dd8a35e007ed3b57695877fbf102dbeb8b3212491398e494314e93726926e1383f8abb5889bea954eb8c0ca1c62c8e9d83f41888095c5e645ed6d32515fe0c58c1368cad84694e18da43668c6f43e61d7c9bca633ddcda7aef5b79bc396d4a9f48e2a9abe0836cc455e435305357228e93d25aaed46b952defae0f57339bf26f5a9
+
+
+class TestModMultiply(unittest.TestCase):
+
+    def test_small(self):
+        self.assertEqual(b"\x01", monty_mult(5, 6, 29))
+
+    def test_large(self):
+        numbers_len = (modulus1.bit_length() + 7) // 8
+
+        t1 = modulus1 // 2
+        t2 = modulus1 - 90
+        expect = b'\x00' * (numbers_len - 1) + b'\x2d'
+        self.assertEqual(expect, monty_mult(t1, t2, modulus1))
+
+    def test_zero_term(self):
+        numbers_len = (modulus1.bit_length() + 7) // 8
+        expect = b'\x00' * numbers_len
+        self.assertEqual(expect, monty_mult(0x100, 0, modulus1))
+        self.assertEqual(expect, monty_mult(0, 0x100, modulus1))
+
+    def test_larger_term(self):
+        t1 = 2**2047
+        expect_int = 0x8edf4071f78e3d7ba622cdbbbef74612e301d69186776ae6bf87ff38c320d9aebaa64889c2f67de2324e6bccd2b10ad89e91fd21ba4bb523904d033eff5e70e62f01a84f41fa90a4f248ef249b82e1d2729253fdfc2a3b5b740198123df8bfbf7057d03e15244ad5f26eb9a099763b5c5972121ec076b0bf899f59bd95f7cc129abddccf24217bce52ca0f3a44c9ccc504765dbb89734205f3ae6a8cc560494a60ea84b27d8e00fa24bdd5b4f1d4232edb61e47d3d984c1fa50a3820a2e580fbc3fc8bc11e99df53b9efadf5a40ac75d384e400905aa6f1d88950cd53b1c54dc2222115ad84a27260fa4d978155c1434c551de1ee7361a17a2f79d4388f78a5d
+        res = bytes_to_long(monty_mult(t1, t1, modulus1))
+        self.assertEqual(res, expect_int)
+
+
+def get_tests(config={}):
+    tests = []
+    tests += list_test_cases(TestModMultiply)
+    return tests
+
+
+if __name__ == '__main__':
+    def suite():
+        return unittest.TestSuite(get_tests())
+    unittest.main(defaultTest='suite')

minigpt2/lib/python3.10/site-packages/Crypto/SelfTest/Protocol/__init__.py

@@ -0,0 +1,45 @@
+# -*- coding: utf-8 -*-
+#
+#  SelfTest/Protocol/__init__.py: Self-tests for Crypto.Protocol
+#
+# Written in 2008 by Dwayne C. Litzenberger <dlitz@dlitz.net>
+#
+# ===================================================================
+# The contents of this file are dedicated to the public domain.  To
+# the extent that dedication to the public domain is not available,
+# everyone is granted a worldwide, perpetual, royalty-free,
+# non-exclusive license to exercise all rights associated with the
+# contents of this file for any purpose whatsoever.
+# No rights are reserved.
+#
+# 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.
+# ===================================================================
+
+"""Self-test for Crypto.Protocol"""
+
+__revision__ = "$Id$"
+
+def get_tests(config={}):
+    tests = []
+    from Crypto.SelfTest.Protocol import test_rfc1751;  tests += test_rfc1751.get_tests(config=config)
+    from Crypto.SelfTest.Protocol import test_KDF;      tests += test_KDF.get_tests(config=config)
+    from Crypto.SelfTest.Protocol import test_ecdh;     tests += test_ecdh.get_tests(config=config)
+
+    from Crypto.SelfTest.Protocol import test_SecretSharing;
+    tests += test_SecretSharing.get_tests(config=config)
+
+    return tests
+
+if __name__ == '__main__':
+    import unittest
+    suite = lambda: unittest.TestSuite(get_tests())
+    unittest.main(defaultTest='suite')
+
+# vim:set ts=4 sw=4 sts=4 expandtab:

minigpt2/lib/python3.10/site-packages/Crypto/SelfTest/Protocol/test_KDF.py

@@ -0,0 +1,809 @@
+# -*- coding: utf-8 -*-
+#
+#  SelfTest/Protocol/test_KDF.py: Self-test for key derivation functions
+#
+# ===================================================================
+# The contents of this file are dedicated to the public domain.  To
+# the extent that dedication to the public domain is not available,
+# everyone is granted a worldwide, perpetual, royalty-free,
+# non-exclusive license to exercise all rights associated with the
+# contents of this file for any purpose whatsoever.
+# No rights are reserved.
+#
+# 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.
+# ===================================================================
+
+import re
+import unittest
+from binascii import unhexlify
+
+from Crypto.Util.py3compat import b, bchr
+
+from Crypto.SelfTest.st_common import list_test_cases
+from Crypto.SelfTest.loader import load_test_vectors, load_test_vectors_wycheproof
+from Crypto.Hash import SHA1, HMAC, SHA256, MD5, SHA224, SHA384, SHA512
+from Crypto.Cipher import AES, DES3
+
+from Crypto.Protocol.KDF import (PBKDF1, PBKDF2, _S2V, HKDF, scrypt,
+                                 bcrypt, bcrypt_check,
+                                 SP800_108_Counter)
+
+from Crypto.Protocol.KDF import _bcrypt_decode
+
+
+def t2b(t):
+    if t is None:
+        return None
+    t2 = t.replace(" ", "").replace("\n", "")
+    return unhexlify(b(t2))
+
+
+class TestVector(object):
+    pass
+
+
+class PBKDF1_Tests(unittest.TestCase):
+
+    # List of tuples with test data.
+    # Each tuple is made up by:
+    #       Item #0: a pass phrase
+    #       Item #1: salt (8 bytes encoded in hex)
+    #       Item #2: output key length
+    #       Item #3: iterations to use
+    #       Item #4: expected result (encoded in hex)
+    _testData = (
+            # From http://www.di-mgt.com.au/cryptoKDFs.html#examplespbkdf
+            ("password", "78578E5A5D63CB06", 16, 1000, "DC19847E05C64D2FAF10EBFB4A3D2A20"),
+    )
+
+    def test1(self):
+        v = self._testData[0]
+        res = PBKDF1(v[0], t2b(v[1]), v[2], v[3], SHA1)
+        self.assertEqual(res, t2b(v[4]))
+
+
+class PBKDF2_Tests(unittest.TestCase):
+
+    # List of tuples with test data.
+    # Each tuple is made up by:
+    #       Item #0: a pass phrase
+    #       Item #1: salt (encoded in hex)
+    #       Item #2: output key length
+    #       Item #3: iterations to use
+    #       Item #4: hash module
+    #       Item #5: expected result (encoded in hex)
+    _testData = (
+            # From http://www.di-mgt.com.au/cryptoKDFs.html#examplespbkdf
+            ("password","78578E5A5D63CB06",24,2048,     SHA1, "BFDE6BE94DF7E11DD409BCE20A0255EC327CB936FFE93643"),
+            # From RFC 6050
+            ("password","73616c74", 20, 1,              SHA1, "0c60c80f961f0e71f3a9b524af6012062fe037a6"),
+            ("password","73616c74", 20, 2,              SHA1, "ea6c014dc72d6f8ccd1ed92ace1d41f0d8de8957"),
+            ("password","73616c74", 20, 4096,           SHA1, "4b007901b765489abead49d926f721d065a429c1"),
+            ("passwordPASSWORDpassword","73616c7453414c5473616c7453414c5473616c7453414c5473616c7453414c5473616c74",
+                                    25, 4096,           SHA1, "3d2eec4fe41c849b80c8d83662c0e44a8b291a964cf2f07038"),
+            ( 'pass\x00word',"7361006c74",16,4096,      SHA1, "56fa6aa75548099dcc37d7f03425e0c3"),
+            # From draft-josefsson-scrypt-kdf-01, Chapter 10
+            ( 'passwd', '73616c74', 64, 1,              SHA256, "55ac046e56e3089fec1691c22544b605f94185216dde0465e68b9d57c20dacbc49ca9cccf179b645991664b39d77ef317c71b845b1e30bd509112041d3a19783"),
+            ( 'Password', '4e61436c', 64, 80000,        SHA256, "4ddcd8f60b98be21830cee5ef22701f9641a4418d04c0414aeff08876b34ab56a1d425a1225833549adb841b51c9b3176a272bdebba1d078478f62b397f33c8d"),
+        )
+
+    def test1(self):
+        # Test only for HMAC-SHA1 as PRF
+
+        def prf_SHA1(p,s):
+            return HMAC.new(p,s,SHA1).digest()
+
+        def prf_SHA256(p,s):
+            return HMAC.new(p,s,SHA256).digest()
+
+        for i in range(len(self._testData)):
+            v = self._testData[i]
+            password = v[0]
+            salt = t2b(v[1])
+            out_len = v[2]
+            iters = v[3]
+            hash_mod = v[4]
+            expected = t2b(v[5])
+
+            if hash_mod is SHA1:
+                res = PBKDF2(password, salt, out_len, iters)
+                self.assertEqual(res, expected)
+
+                res = PBKDF2(password, salt, out_len, iters, prf_SHA1)
+                self.assertEqual(res, expected)
+            else:
+                res = PBKDF2(password, salt, out_len, iters, prf_SHA256)
+                self.assertEqual(res, expected)
+
+    def test2(self):
+        # Verify that prf and hmac_hash_module are mutual exclusive
+        def prf_SHA1(p,s):
+            return HMAC.new(p,s,SHA1).digest()
+
+        self.assertRaises(ValueError, PBKDF2, b("xxx"), b("yyy"), 16, 100,
+                          prf=prf_SHA1, hmac_hash_module=SHA1)
+
+    def test3(self):
+        # Verify that hmac_hash_module works like prf
+
+        password = b("xxx")
+        salt = b("yyy")
+
+        for hashmod in (MD5, SHA1, SHA224, SHA256, SHA384, SHA512):
+
+            pr1 = PBKDF2(password, salt, 16, 100,
+                         prf=lambda p, s: HMAC.new(p,s,hashmod).digest())
+            pr2 = PBKDF2(password, salt, 16, 100, hmac_hash_module=hashmod)
+
+            self.assertEqual(pr1, pr2)
+
+    def test4(self):
+        # Verify that PBKDF2 can take bytes or strings as password or salt
+        k1 = PBKDF2("xxx", b("yyy"), 16, 10)
+        k2 = PBKDF2(b("xxx"), b("yyy"), 16, 10)
+        self.assertEqual(k1, k2)
+
+        k1 = PBKDF2(b("xxx"), "yyy", 16, 10)
+        k2 = PBKDF2(b("xxx"), b("yyy"), 16, 10)
+        self.assertEqual(k1, k2)
+
+
+class S2V_Tests(unittest.TestCase):
+
+    # Sequence of test vectors.
+    # Each test vector is made up by:
+    #   Item #0: a tuple of strings
+    #   Item #1: an AES key
+    #   Item #2: the result
+    #   Item #3: the cipher module S2V is based on
+    # Everything is hex encoded
+    _testData = [
+
+            # RFC5297, A.1
+            (
+             (  '101112131415161718191a1b1c1d1e1f2021222324252627',
+                '112233445566778899aabbccddee' ),
+            'fffefdfcfbfaf9f8f7f6f5f4f3f2f1f0',
+            '85632d07c6e8f37f950acd320a2ecc93',
+            AES
+            ),
+
+            # RFC5297, A.2
+            (
+             (  '00112233445566778899aabbccddeeffdeaddadadeaddadaffeeddcc'+
+                'bbaa99887766554433221100',
+                '102030405060708090a0',
+                '09f911029d74e35bd84156c5635688c0',
+                '7468697320697320736f6d6520706c61'+
+                '696e7465787420746f20656e63727970'+
+                '74207573696e67205349562d414553'),
+            '7f7e7d7c7b7a79787776757473727170',
+            '7bdb6e3b432667eb06f4d14bff2fbd0f',
+            AES
+            ),
+
+        ]
+
+    def test1(self):
+        """Verify correctness of test vector"""
+        for tv in self._testData:
+            s2v = _S2V.new(t2b(tv[1]), tv[3])
+            for s in tv[0]:
+                s2v.update(t2b(s))
+            result = s2v.derive()
+            self.assertEqual(result, t2b(tv[2]))
+
+    def test2(self):
+        """Verify that no more than 127(AES) and 63(TDES)
+        components are accepted."""
+        key = bchr(0) * 8 + bchr(255) * 8
+        for module in (AES, DES3):
+            s2v = _S2V.new(key, module)
+            max_comps = module.block_size*8-1
+            for i in range(max_comps):
+                s2v.update(b("XX"))
+            self.assertRaises(TypeError, s2v.update, b("YY"))
+
+
+class HKDF_Tests(unittest.TestCase):
+
+    # Test vectors from RFC5869, Appendix A
+    # Each tuple is made up by:
+    #       Item #0: hash module
+    #       Item #1: secret
+    #       Item #2: salt
+    #       Item #3: context
+    #       Item #4: expected result
+    _test_vector  = (
+            (
+                SHA256,
+                "0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b",
+                "000102030405060708090a0b0c",
+                "f0f1f2f3f4f5f6f7f8f9",
+                42,
+                "3cb25f25faacd57a90434f64d0362f2a" +
+                "2d2d0a90cf1a5a4c5db02d56ecc4c5bf" +
+                "34007208d5b887185865"
+            ),
+            (
+                SHA256,
+                "000102030405060708090a0b0c0d0e0f" +
+                "101112131415161718191a1b1c1d1e1f" +
+                "202122232425262728292a2b2c2d2e2f" +
+                "303132333435363738393a3b3c3d3e3f" +
+                "404142434445464748494a4b4c4d4e4f",
+                "606162636465666768696a6b6c6d6e6f" +
+                "707172737475767778797a7b7c7d7e7f" +
+                "808182838485868788898a8b8c8d8e8f" +
+                "909192939495969798999a9b9c9d9e9f" +
+                "a0a1a2a3a4a5a6a7a8a9aaabacadaeaf",
+                "b0b1b2b3b4b5b6b7b8b9babbbcbdbebf" +
+                "c0c1c2c3c4c5c6c7c8c9cacbcccdcecf" +
+                "d0d1d2d3d4d5d6d7d8d9dadbdcdddedf" +
+                "e0e1e2e3e4e5e6e7e8e9eaebecedeeef" +
+                "f0f1f2f3f4f5f6f7f8f9fafbfcfdfeff",
+                82,
+                "b11e398dc80327a1c8e7f78c596a4934" +
+                "4f012eda2d4efad8a050cc4c19afa97c" +
+                "59045a99cac7827271cb41c65e590e09" +
+                "da3275600c2f09b8367793a9aca3db71" +
+                "cc30c58179ec3e87c14c01d5c1f3434f" +
+                "1d87"
+            ),
+            (
+                SHA256,
+                "0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b",
+                None,
+                None,
+                42,
+                "8da4e775a563c18f715f802a063c5a31" +
+                "b8a11f5c5ee1879ec3454e5f3c738d2d" +
+                "9d201395faa4b61a96c8"
+            ),
+            (
+                SHA1,
+                "0b0b0b0b0b0b0b0b0b0b0b",
+                "000102030405060708090a0b0c",
+                "f0f1f2f3f4f5f6f7f8f9",
+                42,
+                "085a01ea1b10f36933068b56efa5ad81" +
+                "a4f14b822f5b091568a9cdd4f155fda2" +
+                "c22e422478d305f3f896"
+            ),
+            (
+                SHA1,
+                "000102030405060708090a0b0c0d0e0f" +
+                "101112131415161718191a1b1c1d1e1f" +
+                "202122232425262728292a2b2c2d2e2f" +
+                "303132333435363738393a3b3c3d3e3f" +
+                "404142434445464748494a4b4c4d4e4f",
+                "606162636465666768696a6b6c6d6e6f" +
+                "707172737475767778797a7b7c7d7e7f" +
+                "808182838485868788898a8b8c8d8e8f" +
+                "909192939495969798999a9b9c9d9e9f" +
+                "a0a1a2a3a4a5a6a7a8a9aaabacadaeaf",
+                "b0b1b2b3b4b5b6b7b8b9babbbcbdbebf" +
+                "c0c1c2c3c4c5c6c7c8c9cacbcccdcecf" +
+                "d0d1d2d3d4d5d6d7d8d9dadbdcdddedf" +
+                "e0e1e2e3e4e5e6e7e8e9eaebecedeeef" +
+                "f0f1f2f3f4f5f6f7f8f9fafbfcfdfeff",
+                82,
+                "0bd770a74d1160f7c9f12cd5912a06eb" +
+                "ff6adcae899d92191fe4305673ba2ffe" +
+                "8fa3f1a4e5ad79f3f334b3b202b2173c" +
+                "486ea37ce3d397ed034c7f9dfeb15c5e" +
+                "927336d0441f4c4300e2cff0d0900b52" +
+                "d3b4"
+            ),
+            (
+                SHA1,
+                "0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b",
+                "",
+                "",
+                42,
+                "0ac1af7002b3d761d1e55298da9d0506" +
+                "b9ae52057220a306e07b6b87e8df21d0" +
+                "ea00033de03984d34918"
+            ),
+            (
+                SHA1,
+                "0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c",
+                None,
+                "",
+                42,
+                "2c91117204d745f3500d636a62f64f0a" +
+                "b3bae548aa53d423b0d1f27ebba6f5e5" +
+                "673a081d70cce7acfc48"
+            )
+        )
+
+    def test1(self):
+        for tv in self._test_vector:
+            secret, salt, info, exp = [ t2b(tv[x]) for x in (1,2,3,5) ]
+            key_len, hashmod = [ tv[x] for x in (4,0) ]
+
+            output = HKDF(secret, key_len, salt, hashmod, 1, info)
+            self.assertEqual(output, exp)
+
+    def test2(self):
+        ref = HKDF(b("XXXXXX"), 12, b("YYYY"), SHA1)
+
+        # Same output, but this time split over 2 keys
+        key1, key2 = HKDF(b("XXXXXX"), 6, b("YYYY"), SHA1, 2)
+        self.assertEqual((ref[:6], ref[6:]), (key1, key2))
+
+        # Same output, but this time split over 3 keys
+        key1, key2, key3 = HKDF(b("XXXXXX"), 4, b("YYYY"), SHA1, 3)
+        self.assertEqual((ref[:4], ref[4:8], ref[8:]), (key1, key2, key3))
+
+
+class scrypt_Tests(unittest.TestCase):
+
+    # Test vectors taken from
+    # https://tools.ietf.org/html/rfc7914
+    # - password
+    # - salt
+    # - N
+    # - r
+    # - p
+    data = (
+                (
+                    "",
+                    "",
+                    16,     # 2K
+                    1,
+                    1,
+                    """
+                    77 d6 57 62 38 65 7b 20 3b 19 ca 42 c1 8a 04 97
+                    f1 6b 48 44 e3 07 4a e8 df df fa 3f ed e2 14 42
+                    fc d0 06 9d ed 09 48 f8 32 6a 75 3a 0f c8 1f 17
+                    e8 d3 e0 fb 2e 0d 36 28 cf 35 e2 0c 38 d1 89 06
+                    """
+                ),
+                (
+                    "password",
+                    "NaCl",
+                    1024,   # 1M
+                    8,
+                    16,
+                    """
+                    fd ba be 1c 9d 34 72 00 78 56 e7 19 0d 01 e9 fe
+                    7c 6a d7 cb c8 23 78 30 e7 73 76 63 4b 37 31 62
+                    2e af 30 d9 2e 22 a3 88 6f f1 09 27 9d 98 30 da
+                    c7 27 af b9 4a 83 ee 6d 83 60 cb df a2 cc 06 40
+                    """
+                ),
+                (
+                    "pleaseletmein",
+                    "SodiumChloride",
+                    16384,  # 16M
+                    8,
+                    1,
+                    """
+                    70 23 bd cb 3a fd 73 48 46 1c 06 cd 81 fd 38 eb
+                    fd a8 fb ba 90 4f 8e 3e a9 b5 43 f6 54 5d a1 f2
+                    d5 43 29 55 61 3f 0f cf 62 d4 97 05 24 2a 9a f9
+                    e6 1e 85 dc 0d 65 1e 40 df cf 01 7b 45 57 58 87
+                    """
+                ),
+                (
+                    "pleaseletmein",
+                    "SodiumChloride",
+                    1048576, # 1G
+                    8,
+                    1,
+                    """
+                    21 01 cb 9b 6a 51 1a ae ad db be 09 cf 70 f8 81
+                    ec 56 8d 57 4a 2f fd 4d ab e5 ee 98 20 ad aa 47
+                    8e 56 fd 8f 4b a5 d0 9f fa 1c 6d 92 7c 40 f4 c3
+                    37 30 40 49 e8 a9 52 fb cb f4 5c 6f a7 7a 41 a4
+                    """
+                ),
+            )
+
+    def setUp(self):
+        new_test_vectors = []
+        for tv in self.data:
+            new_tv = TestVector()
+            new_tv.P = b(tv[0])
+            new_tv.S = b(tv[1])
+            new_tv.N = tv[2]
+            new_tv.r = tv[3]
+            new_tv.p = tv[4]
+            new_tv.output = t2b(tv[5])
+            new_tv.dkLen = len(new_tv.output)
+            new_test_vectors.append(new_tv)
+        self.data = new_test_vectors
+
+    def test2(self):
+
+        for tv in self.data:
+            try:
+                output = scrypt(tv.P, tv.S, tv.dkLen, tv.N, tv.r, tv.p)
+            except ValueError as e:
+                if " 2 " in str(e) and tv.N >= 1048576:
+                    import warnings
+                    warnings.warn("Not enough memory to unit test scrypt() with N=1048576", RuntimeWarning)
+                    continue
+                else:
+                    raise e
+            self.assertEqual(output, tv.output)
+
+    def test3(self):
+        ref = scrypt(b("password"), b("salt"), 12, 16, 1, 1)
+
+        # Same output, but this time split over 2 keys
+        key1, key2 = scrypt(b("password"), b("salt"), 6, 16, 1, 1, 2)
+        self.assertEqual((ref[:6], ref[6:]), (key1, key2))
+
+        # Same output, but this time split over 3 keys
+        key1, key2, key3 = scrypt(b("password"), b("salt"), 4, 16, 1, 1, 3)
+        self.assertEqual((ref[:4], ref[4:8], ref[8:]), (key1, key2, key3))
+
+
+class bcrypt_Tests(unittest.TestCase):
+
+    def test_negative_cases(self):
+        self.assertRaises(ValueError, bcrypt, b"1" * 73, 10)
+        self.assertRaises(ValueError, bcrypt, b"1" * 10, 3)
+        self.assertRaises(ValueError, bcrypt, b"1" * 10, 32)
+        self.assertRaises(ValueError, bcrypt, b"1" * 10, 4, salt=b"")
+        self.assertRaises(ValueError, bcrypt, b"1" * 10, 4, salt=b"1")
+        self.assertRaises(ValueError, bcrypt, b"1" * 10, 4, salt=b"1" * 17)
+        self.assertRaises(ValueError, bcrypt, b"1\x00" * 10, 4)
+
+    def test_bytearray_mismatch(self):
+        ref = bcrypt("pwd", 4)
+        bcrypt_check("pwd", ref)
+        bref = bytearray(ref)
+        bcrypt_check("pwd", bref)
+
+        wrong = ref[:-1] + bchr(bref[-1] ^ 0x01)
+        self.assertRaises(ValueError, bcrypt_check, "pwd", wrong)
+
+        wrong = b"x" + ref[1:]
+        self.assertRaises(ValueError, bcrypt_check, "pwd", wrong)
+
+    # https://github.com/patrickfav/bcrypt/wiki/Published-Test-Vectors
+
+    def test_empty_password(self):
+        # password, cost, salt, bcrypt hash
+        tvs = [
+            (b"", 4, b"zVHmKQtGGQob.b/Nc7l9NO", b"$2a$04$zVHmKQtGGQob.b/Nc7l9NO8UlrYcW05FiuCj/SxsFO/ZtiN9.mNzy"),
+            (b"", 5, b"zVHmKQtGGQob.b/Nc7l9NO", b"$2a$05$zVHmKQtGGQob.b/Nc7l9NOWES.1hkVBgy5IWImh9DOjKNU8atY4Iy"),
+            (b"", 6, b"zVHmKQtGGQob.b/Nc7l9NO", b"$2a$06$zVHmKQtGGQob.b/Nc7l9NOjOl7l4oz3WSh5fJ6414Uw8IXRAUoiaO"),
+            (b"", 7, b"zVHmKQtGGQob.b/Nc7l9NO", b"$2a$07$zVHmKQtGGQob.b/Nc7l9NOBsj1dQpBA1HYNGpIETIByoNX9jc.hOi"),
+            (b"", 8, b"zVHmKQtGGQob.b/Nc7l9NO", b"$2a$08$zVHmKQtGGQob.b/Nc7l9NOiLTUh/9MDpX86/DLyEzyiFjqjBFePgO"),
+        ]
+
+        for (idx, (password, cost, salt64, result)) in enumerate(tvs):
+            x = bcrypt(password, cost, salt=_bcrypt_decode(salt64))
+            self.assertEqual(x, result)
+            bcrypt_check(password, result)
+
+    def test_random_password_and_salt_short_pw(self):
+        # password, cost, salt, bcrypt hash
+        tvs = [
+            (b"<.S.2K(Zq'", 4, b"VYAclAMpaXY/oqAo9yUpku", b"$2a$04$VYAclAMpaXY/oqAo9yUpkuWmoYywaPzyhu56HxXpVltnBIfmO9tgu"),
+            (b"5.rApO%5jA", 5, b"kVNDrnYKvbNr5AIcxNzeIu", b"$2a$05$kVNDrnYKvbNr5AIcxNzeIuRcyIF5cZk6UrwHGxENbxP5dVv.WQM/G"),
+            (b"oW++kSrQW^", 6, b"QLKkRMH9Am6irtPeSKN5sO", b"$2a$06$QLKkRMH9Am6irtPeSKN5sObJGr3j47cO6Pdf5JZ0AsJXuze0IbsNm"),
+            (b"ggJ\\KbTnDG", 7, b"4H896R09bzjhapgCPS/LYu", b"$2a$07$4H896R09bzjhapgCPS/LYuMzAQluVgR5iu/ALF8L8Aln6lzzYXwbq"),
+            (b"49b0:;VkH/", 8, b"hfvO2retKrSrx5f2RXikWe", b"$2a$08$hfvO2retKrSrx5f2RXikWeFWdtSesPlbj08t/uXxCeZoHRWDz/xFe"),
+            (b">9N^5jc##'", 9, b"XZLvl7rMB3EvM0c1.JHivu", b"$2a$09$XZLvl7rMB3EvM0c1.JHivuIDPJWeNJPTVrpjZIEVRYYB/mF6cYgJK"),
+            (b"\\$ch)s4WXp", 10, b"aIjpMOLK5qiS9zjhcHR5TO", b"$2a$10$aIjpMOLK5qiS9zjhcHR5TOU7v2NFDmcsBmSFDt5EHOgp/jeTF3O/q"),
+            (b"RYoj\\_>2P7", 12, b"esIAHiQAJNNBrsr5V13l7.", b"$2a$12$esIAHiQAJNNBrsr5V13l7.RFWWJI2BZFtQlkFyiWXjou05GyuREZa"),
+        ]
+
+        for (idx, (password, cost, salt64, result)) in enumerate(tvs):
+            x = bcrypt(password, cost, salt=_bcrypt_decode(salt64))
+            self.assertEqual(x, result)
+            bcrypt_check(password, result)
+
+    def test_random_password_and_salt_long_pw(self):
+        # password, cost, salt, bcrypt hash
+        tvs = [
+            (b"^Q&\"]A`%/A(BVGt>QaX0M-#<Q148&f", 4, b"vrRP5vQxyD4LrqiLd/oWRO", b"$2a$04$vrRP5vQxyD4LrqiLd/oWROgrrGINsw3gb4Ga5x2sn01jNmiLVECl6"),
+            (b"nZa!rRf\\U;OL;R?>1ghq_+\":Y0CRmY", 5, b"YuQvhokOGVnevctykUYpKu", b"$2a$05$YuQvhokOGVnevctykUYpKutZD2pWeGGYn3auyLOasguMY3/0BbIyq"),
+            (b"F%uN/j>[GuB7-jB'_Yj!Tnb7Y!u^6)", 6, b"5L3vpQ0tG9O7k5gQ8nAHAe", b"$2a$06$5L3vpQ0tG9O7k5gQ8nAHAe9xxQiOcOLh8LGcI0PLWhIznsDt.S.C6"),
+            (b"Z>BobP32ub\"Cfe*Q<<WUq3rc=[GJr-", 7, b"hp8IdLueqE6qFh1zYycUZ.", b"$2a$07$hp8IdLueqE6qFh1zYycUZ.twmUH8eSTPQAEpdNXKMlwms9XfKqfea"),
+            (b"Ik&8N['7*[1aCc1lOm8\\jWeD*H$eZM", 8, b"2ANDTYCB9m7vf0Prh7rSru", b"$2a$08$2ANDTYCB9m7vf0Prh7rSrupqpO3jJOkIz2oW/QHB4lCmK7qMytGV6"),
+            (b"O)=%3[E$*q+>-q-=tRSjOBh8\\mLNW.", 9, b"nArqOfdCsD9kIbVnAixnwe", b"$2a$09$nArqOfdCsD9kIbVnAixnwe6s8QvyPYWtQBpEXKir2OJF9/oNBsEFe"),
+            (b"/MH51`!BP&0tj3%YCA;Xk%e3S`o\\EI", 10, b"ePiAc.s.yoBi3B6p1iQUCe", b"$2a$10$ePiAc.s.yoBi3B6p1iQUCezn3mraLwpVJ5XGelVyYFKyp5FZn/y.u"),
+            (b"ptAP\"mcg6oH.\";c0U2_oll.OKi<!ku", 12, b"aroG/pwwPj1tU5fl9a9pkO", b"$2a$12$aroG/pwwPj1tU5fl9a9pkO4rydAmkXRj/LqfHZOSnR6LGAZ.z.jwa"),
+        ]
+
+        for (idx, (password, cost, salt64, result)) in enumerate(tvs):
+            x = bcrypt(password, cost, salt=_bcrypt_decode(salt64))
+            self.assertEqual(x, result)
+            bcrypt_check(password, result)
+
+    def test_same_password_and_random_salt(self):
+        # password, cost, salt, bcrypt hash
+        tvs = [
+            (b"Q/A:k3DP;X@=<0\"hg&9c", 4, b"wbgDTvLMtyjQlNK7fjqwyO", b"$2a$04$wbgDTvLMtyjQlNK7fjqwyOakBoACQuYh11.VsKNarF4xUIOBWgD6S"),
+            (b"Q/A:k3DP;X@=<0\"hg&9c", 5, b"zbAaOmloOhxiKItjznRqru", b"$2a$05$zbAaOmloOhxiKItjznRqrunRqHlu3MAa7pMGv26Rr3WwyfGcwoRm6"),
+            (b"Q/A:k3DP;X@=<0\"hg&9c", 6, b"aOK0bWUvLI0qLkc3ti5jyu", b"$2a$06$aOK0bWUvLI0qLkc3ti5jyuAIQoqRzuqoK09kQqQ6Ou/YKDhW50/qa"),
+        ]
+
+        for (idx, (password, cost, salt64, result)) in enumerate(tvs):
+            x = bcrypt(password, cost, salt=_bcrypt_decode(salt64))
+            self.assertEqual(x, result)
+            bcrypt_check(password, result)
+
+    def test_same_password_and_salt_increasing_cost_factor(self):
+        # password, cost, salt, bcrypt hash
+        tvs = [
+            (b"o<&+X'F4AQ8H,LU,N`&r", 4, b"BK5u.QHk1Driey7bvnFTH.", b"$2a$04$BK5u.QHk1Driey7bvnFTH.3smGwxd91PtoK2GxH5nZ7pcBsYX4lMq"),
+            (b"o<&+X'F4AQ8H,LU,N`&r", 5, b"BK5u.QHk1Driey7bvnFTH.", b"$2a$05$BK5u.QHk1Driey7bvnFTH.t5P.jZvFBMzDB1IY4PwkkRPOyVbEtFG"),
+            (b"o<&+X'F4AQ8H,LU,N`&r", 6, b"BK5u.QHk1Driey7bvnFTH.", b"$2a$06$BK5u.QHk1Driey7bvnFTH.6Ea1Z5db2p25CPXZbxb/3OyKQagg3pa"),
+            (b"o<&+X'F4AQ8H,LU,N`&r", 7, b"BK5u.QHk1Driey7bvnFTH.", b"$2a$07$BK5u.QHk1Driey7bvnFTH.sruuQi8Lhv/0LWKDvNp3AGFk7ltdkm6"),
+            (b"o<&+X'F4AQ8H,LU,N`&r", 8, b"BK5u.QHk1Driey7bvnFTH.", b"$2a$08$BK5u.QHk1Driey7bvnFTH.IE7KsaUzc4m7gzAMlyUPUeiYyACWe0q"),
+            (b"o<&+X'F4AQ8H,LU,N`&r", 9, b"BK5u.QHk1Driey7bvnFTH.", b"$2a$09$BK5u.QHk1Driey7bvnFTH.1v4Xj1dwkp44QNg0cVAoQt4FQMMrvnS"),
+            (b"o<&+X'F4AQ8H,LU,N`&r", 10, b"BK5u.QHk1Driey7bvnFTH.", b"$2a$10$BK5u.QHk1Driey7bvnFTH.ESINe9YntUMcVgFDfkC.Vbhc9vMhNX2"),
+            (b"o<&+X'F4AQ8H,LU,N`&r", 12, b"BK5u.QHk1Driey7bvnFTH.", b"$2a$12$BK5u.QHk1Driey7bvnFTH.QM1/nnGe/f5cTzb6XTTi/vMzcAnycqG"),
+        ]
+
+        for (idx, (password, cost, salt64, result)) in enumerate(tvs):
+            x = bcrypt(password, cost, salt=_bcrypt_decode(salt64))
+            self.assertEqual(x, result)
+            bcrypt_check(password, result)
+
+    def test_long_passwords(self):
+        # password, cost, salt, bcrypt hash
+        tvs = [
+            (b"g*3Q45=\"8NNgpT&mbMJ$Omfr.#ZeW?FP=CE$#roHd?97uL0F-]`?u73c\"\\[.\"*)qU34@VG",
+             4, b"T2XJ5MOWvHQZRijl8LIKkO", b"$2a$04$T2XJ5MOWvHQZRijl8LIKkOQKIyX75KBfuLsuRYOJz5OjwBNF2lM8a"),
+            (b"\\M+*8;&QE=Ll[>5?Ui\"^ai#iQH7ZFtNMfs3AROnIncE9\"BNNoEgO[[*Yk8;RQ(#S,;I+aT",
+             5, b"wgkOlGNXIVE2fWkT3gyRoO", b"$2a$05$wgkOlGNXIVE2fWkT3gyRoOqWi4gbi1Wv2Q2Jx3xVs3apl1w.Wtj8C"),
+            (b"M.E1=dt<.L0Q&p;94NfGm_Oo23+Kpl@M5?WIAL.[@/:'S)W96G8N^AWb7_smmC]>7#fGoB",
+             6, b"W9zTCl35nEvUukhhFzkKMe", b"$2a$06$W9zTCl35nEvUukhhFzkKMekjT9/pj7M0lihRVEZrX3m8/SBNZRX7i"),
+        ]
+
+        for (idx, (password, cost, salt64, result)) in enumerate(tvs):
+            x = bcrypt(password, cost, salt=_bcrypt_decode(salt64))
+            self.assertEqual(x, result)
+            bcrypt_check(password, result)
+
+    def test_increasing_password_length(self):
+        # password, cost, salt, bcrypt hash
+        tvs = [
+            (b"a", 4, b"5DCebwootqWMCp59ISrMJ.", b"$2a$04$5DCebwootqWMCp59ISrMJ.l4WvgHIVg17ZawDIrDM2IjlE64GDNQS"),
+            (b"aa", 4, b"5DCebwootqWMCp59ISrMJ.", b"$2a$04$5DCebwootqWMCp59ISrMJ.AyUxBk.ThHlsLvRTH7IqcG7yVHJ3SXq"),
+            (b"aaa", 4, b"5DCebwootqWMCp59ISrMJ.", b"$2a$04$5DCebwootqWMCp59ISrMJ.BxOVac5xPB6XFdRc/ZrzM9FgZkqmvbW"),
+            (b"aaaa", 4, b"5DCebwootqWMCp59ISrMJ.", b"$2a$04$5DCebwootqWMCp59ISrMJ.Qbr209bpCtfl5hN7UQlG/L4xiD3AKau"),
+            (b"aaaaa", 4, b"5DCebwootqWMCp59ISrMJ.", b"$2a$04$5DCebwootqWMCp59ISrMJ.oWszihPjDZI0ypReKsaDOW1jBl7oOii"),
+            (b"aaaaaa", 4, b"5DCebwootqWMCp59ISrMJ.", b"$2a$04$5DCebwootqWMCp59ISrMJ./k.Xxn9YiqtV/sxh3EHbnOHd0Qsq27K"),
+            (b"aaaaaaa", 4, b"5DCebwootqWMCp59ISrMJ.", b"$2a$04$5DCebwootqWMCp59ISrMJ.PYJqRFQbgRbIjMd5VNKmdKS4sBVOyDe"),
+            (b"aaaaaaaa", 4, b"5DCebwootqWMCp59ISrMJ.", b"$2a$04$5DCebwootqWMCp59ISrMJ..VMYfzaw1wP/SGxowpLeGf13fxCCt.q"),
+            (b"aaaaaaaaa", 4, b"5DCebwootqWMCp59ISrMJ.", b"$2a$04$5DCebwootqWMCp59ISrMJ.5B0p054nO5WgAD1n04XslDY/bqY9RJi"),
+            (b"aaaaaaaaaa", 4, b"5DCebwootqWMCp59ISrMJ.", b"$2a$04$5DCebwootqWMCp59ISrMJ.INBTgqm7sdlBJDg.J5mLMSRK25ri04y"),
+            (b"aaaaaaaaaaa", 4, b"5DCebwootqWMCp59ISrMJ.", b"$2a$04$5DCebwootqWMCp59ISrMJ.s3y7CdFD0OR5p6rsZw/eZ.Dla40KLfm"),
+            (b"aaaaaaaaaaaa", 4, b"5DCebwootqWMCp59ISrMJ.", b"$2a$04$5DCebwootqWMCp59ISrMJ.Jx742Djra6Q7PqJWnTAS.85c28g.Siq"),
+            (b"aaaaaaaaaaaaa", 4, b"5DCebwootqWMCp59ISrMJ.", b"$2a$04$5DCebwootqWMCp59ISrMJ.oKMXW3EZcPHcUV0ib5vDBnh9HojXnLu"),
+            (b"aaaaaaaaaaaaaa", 4, b"5DCebwootqWMCp59ISrMJ.", b"$2a$04$5DCebwootqWMCp59ISrMJ.w6nIjWpDPNSH5pZUvLjC1q25ONEQpeS"),
+            (b"aaaaaaaaaaaaaaa", 4, b"5DCebwootqWMCp59ISrMJ.", b"$2a$04$5DCebwootqWMCp59ISrMJ.k1b2/r9A/hxdwKEKurg6OCn4MwMdiGq"),
+            (b"aaaaaaaaaaaaaaaa", 4, b"5DCebwootqWMCp59ISrMJ.", b"$2a$04$5DCebwootqWMCp59ISrMJ.3prCNHVX1Ws.7Hm2bJxFUnQOX9f7DFa"),
+        ]
+
+        for (idx, (password, cost, salt64, result)) in enumerate(tvs):
+            x = bcrypt(password, cost, salt=_bcrypt_decode(salt64))
+            self.assertEqual(x, result)
+            bcrypt_check(password, result)
+
+    def test_non_ascii_characters(self):
+        # password, cost, salt, bcrypt hash
+        tvs = [
+            ("àèìòùÀÈÌÒÙáéíóúýÁÉÍÓÚÝðÐ", 4, b"D3qS2aoTVyqM7z8v8crLm.", b"$2a$04$D3qS2aoTVyqM7z8v8crLm.3nKt4CzBZJbyFB.ZebmfCvRw7BGs.Xm"),
+            ("àèìòùÀÈÌÒÙáéíóúýÁÉÍÓÚÝðÐ", 5, b"VA1FujiOCMPkUHQ8kF7IaO", b"$2a$05$VA1FujiOCMPkUHQ8kF7IaOg7NGaNvpxwWzSluQutxEVmbZItRTsAa"),
+            ("àèìòùÀÈÌÒÙáéíóúýÁÉÍÓÚÝðÐ", 6, b"TXiaNrPeBSz5ugiQlehRt.", b"$2a$06$TXiaNrPeBSz5ugiQlehRt.gwpeDQnXWteQL4z2FulouBr6G7D9KUi"),
+            ("âêîôûÂÊÎÔÛãñõÃÑÕäëïöüÿ", 4, b"YTn1Qlvps8e1odqMn6G5x.", b"$2a$04$YTn1Qlvps8e1odqMn6G5x.85pqKql6w773EZJAExk7/BatYAI4tyO"),
+            ("âêîôûÂÊÎÔÛãñõÃÑÕäëïöüÿ", 5, b"C.8k5vJKD2NtfrRI9o17DO", b"$2a$05$C.8k5vJKD2NtfrRI9o17DOfIW0XnwItA529vJnh2jzYTb1QdoY0py"),
+            ("âêîôûÂÊÎÔÛãñõÃÑÕäëïöüÿ", 6, b"xqfRPj3RYAgwurrhcA6uRO", b"$2a$06$xqfRPj3RYAgwurrhcA6uROtGlXDp/U6/gkoDYHwlubtcVcNft5.vW"),
+            ("ÄËÏÖÜŸåÅæÆœŒßçÇøØ¢¿¡€", 4, b"y8vGgMmr9EdyxP9rmMKjH.", b"$2a$04$y8vGgMmr9EdyxP9rmMKjH.wv2y3r7yRD79gykQtmb3N3zrwjKsyay"),
+            ("ÄËÏÖÜŸåÅæÆœŒßçÇøØ¢¿¡€", 5, b"iYH4XIKAOOm/xPQs7xKP1u", b"$2a$05$iYH4XIKAOOm/xPQs7xKP1upD0cWyMn3Jf0ZWiizXbEkVpS41K1dcO"),
+            ("ÄËÏÖÜŸåÅæÆœŒßçÇøØ¢¿¡€", 6, b"wCOob.D0VV8twafNDB2ape", b"$2a$06$wCOob.D0VV8twafNDB2apegiGD5nqF6Y1e6K95q6Y.R8C4QGd265q"),
+            ("ΔημοσιεύθηκεστηνΕφημερίδατης", 4, b"E5SQtS6P4568MDXW7cyUp.", b"$2a$04$E5SQtS6P4568MDXW7cyUp.18wfDisKZBxifnPZjAI1d/KTYMfHPYO"),
+            ("АБбВвГгДдЕеЁёЖжЗзИиЙйКкЛлМмН", 4, b"03e26gQFHhQwRNf81/ww9.", b"$2a$04$03e26gQFHhQwRNf81/ww9.p1UbrNwxpzWjLuT.zpTLH4t/w5WhAhC"),
+            ("нОоПпРрСсТтУуФфХхЦцЧчШшЩщЪъЫыЬьЭэЮю", 4, b"PHNoJwpXCfe32nUtLv2Upu", b"$2a$04$PHNoJwpXCfe32nUtLv2UpuhJXOzd4k7IdFwnEpYwfJVCZ/f/.8Pje"),
+            ("電电電島岛島兔兔兎龜龟亀國国国區区区", 4, b"wU4/0i1TmNl2u.1jIwBX.u", b"$2a$04$wU4/0i1TmNl2u.1jIwBX.uZUaOL3Rc5ID7nlQRloQh6q5wwhV/zLW"),
+            ("诶比伊艾弗豆贝尔维吾艾尺开艾丝维贼德", 4, b"P4kreGLhCd26d4WIy7DJXu", b"$2a$04$P4kreGLhCd26d4WIy7DJXusPkhxLvBouzV6OXkL5EB0jux0osjsry"),
+        ]
+
+        for (idx, (password, cost, salt64, result)) in enumerate(tvs):
+            x = bcrypt(password, cost, salt=_bcrypt_decode(salt64))
+            self.assertEqual(x, result)
+            bcrypt_check(password, result)
+
+    def test_special_case_salt(self):
+        # password, cost, salt, bcrypt hash
+        tvs = [
+            ("-O_=*N!2JP", 4, b"......................", b"$2a$04$......................JjuKLOX9OOwo5PceZZXSkaLDvdmgb82"),
+            ("7B[$Q<4b>U", 5, b"......................", b"$2a$05$......................DRiedDQZRL3xq5A5FL8y7/6NM8a2Y5W"),
+            (">d5-I_8^.h", 6, b"......................", b"$2a$06$......................5Mq1Ng8jgDY.uHNU4h5p/x6BedzNH2W"),
+            (")V`/UM/]1t", 4, b".OC/.OC/.OC/.OC/.OC/.O", b"$2a$04$.OC/.OC/.OC/.OC/.OC/.OQIvKRDAam.Hm5/IaV/.hc7P8gwwIbmi"),
+            (":@t2.bWuH]", 5, b".OC/.OC/.OC/.OC/.OC/.O", b"$2a$05$.OC/.OC/.OC/.OC/.OC/.ONDbUvdOchUiKmQORX6BlkPofa/QxW9e"),
+            ("b(#KljF5s\"", 6, b".OC/.OC/.OC/.OC/.OC/.O", b"$2a$06$.OC/.OC/.OC/.OC/.OC/.OHfTd9e7svOu34vi1PCvOcAEq07ST7.K"),
+            ("@3YaJ^Xs]*", 4, b"eGA.eGA.eGA.eGA.eGA.e.", b"$2a$04$eGA.eGA.eGA.eGA.eGA.e.stcmvh.R70m.0jbfSFVxlONdj1iws0C"),
+            ("'\"5\\!k*C(p", 5, b"eGA.eGA.eGA.eGA.eGA.e.", b"$2a$05$eGA.eGA.eGA.eGA.eGA.e.vR37mVSbfdHwu.F0sNMvgn8oruQRghy"),
+            ("edEu7C?$'W", 6, b"eGA.eGA.eGA.eGA.eGA.e.", b"$2a$06$eGA.eGA.eGA.eGA.eGA.e.tSq0FN8MWHQXJXNFnHTPQKtA.n2a..G"),
+            ("N7dHmg\\PI^", 4, b"999999999999999999999u", b"$2a$04$999999999999999999999uCZfA/pLrlyngNDMq89r1uUk.bQ9icOu"),
+            ("\"eJuHh!)7*", 5, b"999999999999999999999u", b"$2a$05$999999999999999999999uj8Pfx.ufrJFAoWFLjapYBS5vVEQQ/hK"),
+            ("ZeDRJ:_tu:", 6, b"999999999999999999999u", b"$2a$06$999999999999999999999u6RB0P9UmbdbQgjoQFEJsrvrKe.BoU6q"),
+        ]
+
+        for (idx, (password, cost, salt64, result)) in enumerate(tvs):
+            x = bcrypt(password, cost, salt=_bcrypt_decode(salt64))
+            self.assertEqual(x, result)
+            bcrypt_check(password, result)
+
+
+class TestVectorsHKDFWycheproof(unittest.TestCase):
+
+    def __init__(self, wycheproof_warnings):
+        unittest.TestCase.__init__(self)
+        self._wycheproof_warnings = wycheproof_warnings
+        self._id = "None"
+
+    def add_tests(self, filename):
+
+        def filter_algo(root):
+            algo_name = root['algorithm']
+            if algo_name == "HKDF-SHA-1":
+                return SHA1
+            elif algo_name == "HKDF-SHA-256":
+                return SHA256
+            elif algo_name == "HKDF-SHA-384":
+                return SHA384
+            elif algo_name == "HKDF-SHA-512":
+                return SHA512
+            else:
+                raise ValueError("Unknown algorithm " + algo_name)
+
+        def filter_size(unit):
+            return int(unit['size'])
+
+        result = load_test_vectors_wycheproof(("Protocol", "wycheproof"),
+                                              filename,
+                                              "Wycheproof HMAC (%s)" % filename,
+                                              root_tag={'hash_module': filter_algo},
+                                              unit_tag={'size': filter_size})
+        return result
+
+    def setUp(self):
+        self.tv = []
+        self.add_tests("hkdf_sha1_test.json")
+        self.add_tests("hkdf_sha256_test.json")
+        self.add_tests("hkdf_sha384_test.json")
+        self.add_tests("hkdf_sha512_test.json")
+
+    def shortDescription(self):
+        return self._id
+
+    def warn(self, tv):
+        if tv.warning and self._wycheproof_warnings:
+            import warnings
+            warnings.warn("Wycheproof warning: %s (%s)" % (self._id, tv.comment))
+
+    def test_verify(self, tv):
+        self._id = "Wycheproof HKDF Test #%d (%s, %s)" % (tv.id, tv.comment, tv.filename)
+
+        try:
+            key = HKDF(tv.ikm, tv.size, tv.salt, tv.hash_module, 1, tv.info)
+        except ValueError:
+            assert not tv.valid
+        else:
+            if key != tv.okm:
+                assert not tv.valid
+            else:
+                assert tv.valid
+                self.warn(tv)
+
+    def runTest(self):
+        for tv in self.tv:
+            self.test_verify(tv)
+
+
+def load_hash_by_name(hash_name):
+    return __import__("Crypto.Hash." + hash_name, globals(), locals(), ["new"])
+
+
+class SP800_180_Counter_Tests(unittest.TestCase):
+
+    def test_negative_zeroes(self):
+        def prf(s, x):
+            return HMAC.new(s, x, SHA256).digest()
+
+        try:
+            _ = SP800_108_Counter(b'0' * 16, 1, prf, label=b'A\x00B')
+        except ValueError:
+            self.fail('SP800_108_Counter failed with zero in label')
+        self.assertRaises(ValueError, SP800_108_Counter, b'0' * 16, 1, prf,
+                          context=b'A\x00B')
+
+    def test_multiple_keys(self):
+        def prf(s, x):
+            return HMAC.new(s, x, SHA256).digest()
+
+        key = b'0' * 16
+        expected = SP800_108_Counter(key, 2*3*23, prf)
+        for r in (1, 2, 3, 23):
+            dks = SP800_108_Counter(key, r, prf, 138//r)
+            self.assertEqual(len(dks), 138//r)
+            self.assertEqual(len(dks[0]), r)
+            self.assertEqual(b''.join(dks), expected)
+
+
+def add_tests_sp800_108_counter(cls):
+
+    test_vectors_sp800_108_counter = load_test_vectors(("Protocol", ),
+                                                       "KDF_SP800_108_COUNTER.txt",
+                                                       "NIST SP 800 108 KDF Counter Mode",
+                                                       {'count': lambda x: int(x)},
+                                                      ) or []
+
+    mac_type = None
+    for idx, tv in enumerate(test_vectors_sp800_108_counter):
+
+        if isinstance(tv, str):
+            res = re.match(r"\[HMAC-(SHA-[0-9]+)\]", tv)
+            if res:
+                hash_name = res.group(1).replace("-", "")
+                hash_module = load_hash_by_name(hash_name)
+                mac_type = "hmac"
+                continue
+            res = re.match(r"\[CMAC-AES-128\]", tv)
+            if res:
+                mac_type = "cmac"
+                continue
+            assert res
+
+        if mac_type == "hmac":
+            def prf(s, x, hash_module=hash_module):
+                return HMAC.new(s, x, hash_module).digest()
+        elif mac_type == "cmac":
+            def prf(s, x, hash_module=hash_module):
+                return CMAC.new(s, x, AES).digest()
+            continue
+
+        def kdf_test(self, prf=prf, kin=tv.kin, label=tv.label,
+                     context=tv.context, kout=tv.kout, count=tv.count):
+            result = SP800_108_Counter(kin, len(kout), prf, 1, label, context)
+            assert(len(result) == len(kout))
+            self.assertEqual(result, kout)
+
+        setattr(cls, "test_kdf_sp800_108_counter_%d" % idx, kdf_test)
+
+
+add_tests_sp800_108_counter(SP800_180_Counter_Tests)
+
+
+def get_tests(config={}):
+    wycheproof_warnings = config.get('wycheproof_warnings')
+
+    if not config.get('slow_tests'):
+        PBKDF2_Tests._testData = PBKDF2_Tests._testData[:3]
+        scrypt_Tests.data = scrypt_Tests.data[:3]
+
+    tests = []
+    tests += list_test_cases(PBKDF1_Tests)
+    tests += list_test_cases(PBKDF2_Tests)
+    tests += list_test_cases(S2V_Tests)
+    tests += list_test_cases(HKDF_Tests)
+    tests += [TestVectorsHKDFWycheproof(wycheproof_warnings)]
+    tests += list_test_cases(scrypt_Tests)
+    tests += list_test_cases(bcrypt_Tests)
+    tests += list_test_cases(SP800_180_Counter_Tests)
+
+    return tests
+
+
+if __name__ == '__main__':
+    suite = lambda: unittest.TestSuite(get_tests())
+    unittest.main(defaultTest='suite')

minigpt2/lib/python3.10/site-packages/Crypto/SelfTest/Protocol/test_SecretSharing.py

@@ -0,0 +1,267 @@
+#
+#  SelfTest/Protocol/test_secret_sharing.py: Self-test for secret sharing protocols
+#
+# ===================================================================
+#
+# Copyright (c) 2014, Legrandin <helderijs@gmail.com>
+# All rights reserved.
+#
+# Redistribution and use in source and binary forms, with or without
+# modification, are permitted provided that the following conditions
+# are met:
+#
+# 1. Redistributions of source code must retain the above copyright
+#    notice, this list of conditions and the following disclaimer.
+# 2. Redistributions in binary form must reproduce the above copyright
+#    notice, this list of conditions and the following disclaimer in
+#    the documentation and/or other materials provided with the
+#    distribution.
+#
+# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+# "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+# LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
+# FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
+# COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
+# INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
+# BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+# LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+# CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+# LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
+# ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+# POSSIBILITY OF SUCH DAMAGE.
+# ===================================================================
+
+from unittest import main, TestCase, TestSuite
+from binascii import unhexlify, hexlify
+
+from Crypto.Util.py3compat import *
+from Crypto.SelfTest.st_common import list_test_cases
+
+from Crypto.Protocol.SecretSharing import Shamir, _Element, \
+                                          _mult_gf2, _div_gf2
+
+class GF2_Tests(TestCase):
+
+    def test_mult_gf2(self):
+        # Prove mult by zero
+        x = _mult_gf2(0,0)
+        self.assertEqual(x, 0)
+
+        # Prove mult by unity
+        x = _mult_gf2(34, 1)
+        self.assertEqual(x, 34)
+
+        z = 3                       # (x+1)
+        y = _mult_gf2(z, z)
+        self.assertEqual(y, 5)      # (x+1)^2 = x^2 + 1
+        y = _mult_gf2(y, z)
+        self.assertEqual(y, 15)     # (x+1)^3 = x^3 + x^2 + x + 1
+        y = _mult_gf2(y, z)
+        self.assertEqual(y, 17)     # (x+1)^4 = x^4 + 1
+
+        # Prove linearity works
+        comps = [1, 4, 128, 2**34]
+        sum_comps = 1+4+128+2**34
+        y = 908
+        z = _mult_gf2(sum_comps, y)
+        w = 0
+        for x in comps:
+            w ^= _mult_gf2(x, y)
+        self.assertEqual(w, z)
+
+    def test_div_gf2(self):
+        from Crypto.Util.number import size as deg
+
+        x, y = _div_gf2(567, 7)
+        self.assertTrue(deg(y) < deg(7))
+
+        w = _mult_gf2(x, 7) ^ y
+        self.assertEqual(567, w)
+
+        x, y = _div_gf2(7, 567)
+        self.assertEqual(x, 0)
+        self.assertEqual(y, 7)
+
+class Element_Tests(TestCase):
+
+    def test1(self):
+        # Test encondings
+        e = _Element(256)
+        self.assertEqual(int(e), 256)
+        self.assertEqual(e.encode(), bchr(0)*14 + b("\x01\x00"))
+
+        e = _Element(bchr(0)*14 + b("\x01\x10"))
+        self.assertEqual(int(e), 0x110)
+        self.assertEqual(e.encode(), bchr(0)*14 + b("\x01\x10"))
+
+        # Only 16 byte string are a valid encoding
+        self.assertRaises(ValueError, _Element, bchr(0))
+
+    def test2(self):
+        # Test addition
+        e = _Element(0x10)
+        f = _Element(0x0A)
+        self.assertEqual(int(e+f), 0x1A)
+
+    def test3(self):
+        # Test multiplication
+        zero = _Element(0)
+        one = _Element(1)
+        two = _Element(2)
+
+        x = _Element(6) * zero
+        self.assertEqual(int(x), 0)
+
+        x = _Element(6) * one
+        self.assertEqual(int(x), 6)
+
+        x = _Element(2**127) * two
+        self.assertEqual(int(x), 1 + 2 + 4 + 128)
+
+    def test4(self):
+        # Test inversion
+        one = _Element(1)
+
+        x = one.inverse()
+        self.assertEqual(int(x), 1)
+
+        x = _Element(82323923)
+        y = x.inverse()
+        self.assertEqual(int(x * y), 1)
+
+class Shamir_Tests(TestCase):
+
+    def test1(self):
+        # Test splitting
+        shares = Shamir.split(2, 3, bchr(90)*16)
+        self.assertEqual(len(shares), 3)
+        for index in range(3):
+            self.assertEqual(shares[index][0], index+1)
+            self.assertEqual(len(shares[index][1]), 16)
+
+    def test2(self):
+        # Test recombine
+        from itertools import permutations
+
+        test_vectors = (
+            (2, "d9fe73909bae28b3757854c0af7ad405",
+             "1-594ae8964294174d95c33756d2504170",
+             "2-d897459d29da574eb40e93ec552ffe6e",
+             "3-5823de9bf0e068b054b5f07a28056b1b",
+             "4-db2c1f8bff46d748f795da995bd080cb"),
+            (2, "bf4f902d9a7efafd1f3ffd9291fd5de9",
+             "1-557bd3b0748064b533469722d1cc7935",
+             "2-6b2717164783c66d47cd28f2119f14d0",
+             "3-8113548ba97d58256bb4424251ae300c",
+             "4-179e9e5a218483ddaeda57539139cf04"),
+            (3, "ec96aa5c14c9faa699354cf1da74e904",
+             "1-64579fbf1908d66f7239bf6e2b4e41e1",
+             "2-6cd9428df8017b52322561e8c672ae3e",
+             "3-e418776ef5c0579bd9299277374806dd",
+             "4-ab3f77a0107398d23b323e581bb43f5d",
+             "5-23fe42431db2b41bd03ecdc7ea8e97ac"),
+            (3, "44cf249b68b80fcdc27b47be60c2c145",
+             "1-d6515a3905cd755119b86e311c801e31",
+             "2-16693d9ac9f10c254036ced5f8917fa3",
+             "3-84f74338a48476b99bf5e75a84d3a0d1",
+             "4-3fe8878dc4a5d35811cf3cbcd33dbe52",
+             "5-ad76f92fa9d0a9c4ca0c1533af7f6132"),
+            (5, "5398717c982db935d968eebe53a47f5a",
+             "1-be7be2dd4c068e7ef576aaa1b1c11b01",
+             "2-f821f5848441cb98b3eb467e2733ee21",
+             "3-25ee52f53e203f6e29a0297b5ab486b5",
+             "4-fc9fb58ef74dab947fbf9acd9d5d83cd",
+             "5-b1949cce46d81552e65f248d3f74cc5c",
+             "6-d64797f59977c4d4a7956ad916da7699",
+             "7-ab608a6546a8b9af8820ff832b1135c7"),
+            (5, "4a78db90fbf35da5545d2fb728e87596",
+             "1-08daf9a25d8aa184cfbf02b30a0ed6a0",
+             "2-dda28261e36f0b14168c2cf153fb734e",
+             "3-e9fdec5505d674a57f9836c417c1ecaa",
+             "4-4dce5636ae06dee42d2c82e65f06c735",
+             "5-3963dc118afc2ba798fa1d452b28ef00",
+             "6-6dfe6ff5b09e94d2f84c382b12f42424",
+             "7-6faea9d4d4a4e201bf6c90b9000630c3"),
+            (10, "eccbf6d66d680b49b073c4f1ddf804aa",
+             "01-7d8ac32fe4ae209ead1f3220fda34466",
+             "02-f9144e76988aad647d2e61353a6e96d5",
+             "03-b14c3b80179203363922d60760271c98",
+             "04-770bb2a8c28f6cee89e00f4d5cc7f861",
+             "05-6e3d7073ea368334ef67467871c66799",
+             "06-248792bc74a98ce024477c13c8fb5f8d",
+             "07-fcea4640d2db820c0604851e293d2487",
+             "08-2776c36fb714bb1f8525a0be36fc7dba",
+             "09-6ee7ac8be773e473a4bf75ee5f065762",
+             "10-33657fc073354cf91d4a68c735aacfc8",
+             "11-7645c65094a5868bf225c516fdee2d0c",
+             "12-840485aacb8226631ecd9c70e3018086"),
+            (10, "377e63bdbb5f7d4dc58a483d035212bb",
+             "01-32c53260103be431c843b1a633afe3bd",
+             "02-0107eb16cb8695084d452d2cc50bc7d6",
+             "03-df1e5c66cd755287fb0446faccd72a06",
+             "04-361bbcd5d40797f49dfa1898652da197",
+             "05-160d3ad1512f7dec7fd9344aed318591",
+             "06-659af6d95df4f25beca4fb9bfee3b7e8",
+             "07-37f3b208977bad50b3724566b72bfa9d",
+             "08-6c1de2dfc69c2986142c26a8248eb316",
+             "09-5e19220837a396bd4bc8cd685ff314c3",
+             "10-86e7b864fb0f3d628e46d50c1ba92f1c",
+             "11-065d0082c80b1aea18f4abe0c49df72e",
+             "12-84a09430c1d20ea9f388f3123c3733a3"),
+        )
+
+        def get_share(p):
+            pos = p.find('-')
+            return int(p[:pos]), unhexlify(p[pos + 1:])
+
+        for tv in test_vectors:
+            k = tv[0]
+            secret = unhexlify(tv[1])
+            max_perms = 10
+            for perm, shares_idx in enumerate(permutations(range(2, len(tv)), k)):
+                if perm > max_perms:
+                    break
+                shares = [ get_share(tv[x]) for x in shares_idx ]
+                result = Shamir.combine(shares, True)
+                self.assertEqual(secret, result)
+
+    def test3(self):
+        # Loopback split/recombine
+        secret = unhexlify(b("000102030405060708090a0b0c0d0e0f"))
+
+        shares = Shamir.split(2, 3, secret)
+
+        secret2 = Shamir.combine(shares[:2])
+        self.assertEqual(secret, secret2)
+
+        secret3 = Shamir.combine([ shares[0], shares[2] ])
+        self.assertEqual(secret, secret3)
+
+    def test4(self):
+        # Loopback split/recombine (SSSS)
+        secret = unhexlify(b("000102030405060708090a0b0c0d0e0f"))
+
+        shares = Shamir.split(2, 3, secret, ssss=True)
+
+        secret2 = Shamir.combine(shares[:2], ssss=True)
+        self.assertEqual(secret, secret2)
+
+    def test5(self):
+        # Detect duplicate shares
+        secret = unhexlify(b("000102030405060708090a0b0c0d0e0f"))
+
+        shares = Shamir.split(2, 3, secret)
+        self.assertRaises(ValueError, Shamir.combine, (shares[0], shares[0]))
+
+
+def get_tests(config={}):
+    tests = []
+    tests += list_test_cases(GF2_Tests)
+    tests += list_test_cases(Element_Tests)
+    tests += list_test_cases(Shamir_Tests)
+    return tests
+
+if __name__ == '__main__':
+    suite = lambda: TestSuite(get_tests())
+    main(defaultTest='suite')
+

minigpt2/lib/python3.10/site-packages/Crypto/SelfTest/Protocol/test_ecdh.py

@@ -0,0 +1,619 @@
+import re
+import base64
+import unittest
+from binascii import hexlify, unhexlify
+
+from Crypto.Util.py3compat import bord
+
+from Crypto.Hash import SHA256
+from Crypto.PublicKey import ECC
+from Crypto.SelfTest.st_common import list_test_cases
+from Crypto.SelfTest.loader import load_test_vectors, load_test_vectors_wycheproof
+
+from Crypto.Protocol import DH
+from Crypto.Protocol.DH import (key_agreement,
+                                import_x25519_public_key,
+                                import_x25519_private_key)
+
+
+class FIPS_ECDH_Tests_KAT(unittest.TestCase):
+    pass
+
+
+test_vectors_verify = load_test_vectors(("Protocol", ),
+                                        "KAS_ECC_CDH_PrimitiveTest.txt",
+                                        "ECC CDH Primitive (SP800-56A Section 5.7.1.2)",
+                                        {
+                                        'qcavsx': lambda x: int(x, 16),
+                                        'qcavsy': lambda x: int(x, 16),
+                                        'diut': lambda x: int(x, 16),
+                                        'qiutx': lambda x: int(x, 16),
+                                        'qiuty': lambda x: int(x, 16),
+                                        }) or []
+
+for idx, tv in enumerate(test_vectors_verify):
+
+    # Stand-alone header with curve name
+    if isinstance(tv, str):
+        res = re.match(r"\[([A-Za-z0-9-]+)\]", tv)
+        assert res
+        curve_name = res.group(1)
+        continue
+
+    public_key = ECC.construct(curve=curve_name,
+                               point_x=tv.qcavsx,
+                               point_y=tv.qcavsy)
+
+    private_key = ECC.construct(curve=curve_name,
+                                d=tv.diut)
+
+    exp_response = tv.ziut
+
+    def ecdh_test(self,
+                  public_key=public_key,
+                  private_key=private_key,
+                  exp_response=exp_response):
+        z = key_agreement(
+                static_pub=public_key,
+                static_priv=private_key,
+                kdf=lambda x: x)
+        self.assertEqual(z, exp_response)
+
+    def ecdh_test_rev(self,
+                      public_key=public_key,
+                      private_key=private_key,
+                      exp_response=exp_response):
+        z = key_agreement(
+                static_pub=public_key,
+                static_priv=private_key,
+                kdf=lambda x: x)
+        self.assertEqual(z, exp_response)
+
+    setattr(FIPS_ECDH_Tests_KAT, "test_verify_positive_%d" % idx, ecdh_test)
+    if idx == 1:
+        setattr(FIPS_ECDH_Tests_KAT, "test_verify_positive_rev_%d" % idx, ecdh_test_rev)
+
+
+class TestVectorsECDHWycheproof(unittest.TestCase):
+
+    desc = "Wycheproof ECDH tests"
+
+    def add_tests(self, filename):
+
+        def curve(g):
+            return g['curve']
+
+        def private(u):
+            return int(u['private'], 16)
+
+        result = load_test_vectors_wycheproof(("Protocol", "wycheproof"),
+                                              filename,
+                                              "Wycheproof ECDH (%s)"
+                                              % filename,
+                                              group_tag={'curve': curve},
+                                              unit_tag={'private': private},
+                                              )
+        self.tv += result
+
+    def setUp(self):
+        self.tv = []
+        self.desc = None
+
+        self.add_tests("ecdh_secp224r1_ecpoint_test.json")
+        self.add_tests("ecdh_secp256r1_ecpoint_test.json")
+        self.add_tests("ecdh_secp384r1_ecpoint_test.json")
+        self.add_tests("ecdh_secp521r1_ecpoint_test.json")
+
+        self.add_tests("ecdh_secp224r1_test.json")
+        self.add_tests("ecdh_secp256r1_test.json")
+        self.add_tests("ecdh_secp384r1_test.json")
+        self.add_tests("ecdh_secp521r1_test.json")
+
+    def shortDescription(self):
+        return self.desc
+
+    def test_verify(self, tv):
+
+        if len(tv.public) == 0:
+            return
+
+        try:
+            if bord(tv.public[0]) == 4:     # SEC1
+                public_key = ECC.import_key(tv.public, curve_name=tv.curve)
+            else:
+                public_key = ECC.import_key(tv.public)
+        except ValueError:
+            assert tv.warning or not tv.valid
+            return
+
+        private_key = ECC.construct(curve=tv.curve, d=tv.private)
+
+        try:
+            z = key_agreement(static_pub=public_key,
+                              static_priv=private_key,
+                              kdf=lambda x: x)
+        except ValueError:
+            assert not tv.valid
+        except TypeError as e:
+            assert not tv.valid
+            assert "incompatible curve" in str(e)
+        else:
+            self.assertEqual(z, tv.shared)
+            assert tv.valid
+
+    def runTest(self):
+        for tv in self.tv:
+            self.desc = "Wycheproof ECDH Verify Test #%d (%s, %s)" % (tv.id, tv.comment, tv.filename)
+            self.test_verify(tv)
+
+
+class ECDH_Tests(unittest.TestCase):
+
+    static_priv = ECC.import_key('-----BEGIN PRIVATE KEY-----\nMIGHAgEAMBMGByqGSM49AgEGCCqGSM49AwEHBG0wawIBAQQg9VHFVKh2a1aVFifH\n+BiyNaRa2kttEg3165Ye/dJxJ7KhRANCAARImIEXro5ZOcyWU2mq/+d79FEZXtTA\nbKkz1aICQXihQdCMzRNbeNtC9LFLzhu1slRKJ2xsDAlw9r6w6vwtkRzr\n-----END PRIVATE KEY-----')
+    static_pub = ECC.import_key('-----BEGIN PRIVATE KEY-----\nMIGHAgEAMBMGByqGSM49AgEGCCqGSM49AwEHBG0wawIBAQQgHhmv8zmZ+Nw8fsZd\ns8tlZflyfw2NE1CRS9DWr3Y3O46hRANCAAS3hZVUCbk+uk3w4S/YOraEVGG+WYpk\nNO/vrwzufUUks2GV2OnBQESe0EBk4Jq8gn4ij8Lvs3rZX2yT+XfeATYd\n-----END PRIVATE KEY-----').public_key()
+
+    eph_priv = ECC.import_key('-----BEGIN PRIVATE KEY-----\nMIGHAgEAMBMGByqGSM49AgEGCCqGSM49AwEHBG0wawIBAQQgGPdJmFFFKzLPspIr\nE1T2cEjeIf4ajS9CpneP0e2b3AyhRANCAAQBexAA5BYDcXHs2KOksTYUsst4HhPt\nkp0zkgI2virc3OGJFNGPaCCPfFCQJHwLRaEpiq3SoQlgoBwSc8ZPsl3y\n-----END PRIVATE KEY-----')
+
+    eph_pub = ECC.import_key('-----BEGIN PRIVATE KEY-----\nMIGHAgEAMBMGByqGSM49AgEGCCqGSM49AwEHBG0wawIBAQQghaVZXElSEGEojFKF\nOU0JCpxWUWHvWQUR81gwWrOp76ShRANCAATi1Ib2K+YR3AckD8wxypWef7pw5PRw\ntBaB3RDPyE7IjHZC6yu1DbcXoCdtaw+F5DM+4zpl59n5ZaIy/Yl1BdIy\n-----END PRIVATE KEY-----')
+
+    def test_1(self):
+        # C(0, 2s)
+        kdf = lambda x: SHA256.new(x).digest()
+        z = key_agreement(
+                kdf=kdf,
+                static_pub=self.static_pub,
+                static_priv=self.static_priv)
+        self.assertEqual(hexlify(z),
+                         b"3960a1101d1193cbaffef4cc7202ebff783c22c6d2e0d5d530ffc66dc197ea9c")
+
+    def test_2(self):
+        # C(2e, 2s)
+        kdf = lambda x: SHA256.new(x).digest()
+        z = key_agreement(
+                kdf=kdf,
+                static_pub=self.static_pub,
+                static_priv=self.static_priv,
+                eph_pub=self.eph_pub,
+                eph_priv=self.eph_priv)
+        self.assertEqual(hexlify(z),
+                         b"7447b733d40c8fab2c633b3dc61e4a8c742f3a6af7e16fb0cc486f5bdb5d6ba2")
+
+    def test_3(self):
+        # C(1e, 2s)
+        kdf = lambda x: SHA256.new(x).digest()
+        z = key_agreement(
+                kdf=kdf,
+                static_pub=self.static_pub,
+                static_priv=self.static_priv,
+                eph_priv=self.eph_priv)
+        self.assertEqual(hexlify(z),
+                         b"9e977ae45f33bf67f285d064d83e6632bcafe3a7d33fe571233bab4794ace759")
+
+    def test_4(self):
+        # C(1e, 2s)
+        kdf = lambda x: SHA256.new(x).digest()
+        z = key_agreement(
+                kdf=kdf,
+                static_pub=self.static_pub,
+                static_priv=self.static_priv,
+                eph_pub=self.eph_pub)
+        self.assertEqual(hexlify(z),
+                         b"c9532df6aa7e9dbe5fe85da31ee25ff19c179c88691ec4b8328cc2036dcdadf2")
+
+    def test_5(self):
+        # C(2e, 1s) is not supported
+        kdf = lambda x: SHA256.new(x).digest()
+        self.assertRaises(ValueError,
+                key_agreement,
+                kdf=kdf,
+                static_priv=self.static_priv,
+                eph_pub=self.eph_pub,
+                eph_priv=self.eph_priv)
+
+    def test_6(self):
+        # C(2e, 1s) is not supported
+        kdf = lambda x: SHA256.new(x).digest()
+        self.assertRaises(ValueError,
+                key_agreement,
+                kdf=kdf,
+                static_pub=self.static_pub,
+                eph_pub=self.eph_pub,
+                eph_priv=self.eph_priv)
+
+    def test_7(self):
+        # C(2e, 0)
+        kdf = lambda x: SHA256.new(x).digest()
+        z = key_agreement(
+                kdf=kdf,
+                eph_pub=self.eph_pub,
+                eph_priv=self.eph_priv)
+        self.assertEqual(hexlify(z),
+                         b"feb257ebe063078b1391aac07913283d7b642ad7df61b46dfc9cd6f420bb896a")
+
+    def test_8(self):
+        # C(1e, 1s)
+        kdf = lambda x: SHA256.new(x).digest()
+        z = key_agreement(
+                kdf=kdf,
+                static_priv=self.static_priv,
+                eph_pub=self.eph_pub)
+        self.assertEqual(hexlify(z),
+                         b"ee4dc995117476ed57fd17ff0ed44e9f0466d46b929443bc0db9380317583b04")
+
+    def test_9(self):
+        # C(1e, 1s)
+        kdf = lambda x: SHA256.new(x).digest()
+        z = key_agreement(
+                kdf=kdf,
+                static_pub=self.static_pub,
+                eph_priv=self.eph_priv)
+        self.assertEqual(hexlify(z),
+                         b"2351cc2014f7c40468fa072b5d30f706eeaeef7507311cd8e59bab3b43f03c51")
+
+    def test_10(self):
+        # No private (local) keys
+        kdf = lambda x: SHA256.new(x).digest()
+        self.assertRaises(ValueError,
+                key_agreement,
+                kdf=kdf,
+                static_pub=self.static_pub,
+                eph_pub=self.eph_pub)
+
+    def test_11(self):
+        # No public (peer) keys
+        kdf = lambda x: SHA256.new(x).digest()
+        self.assertRaises(ValueError,
+                key_agreement,
+                kdf=kdf,
+                static_priv=self.static_priv,
+                eph_priv=self.eph_priv)
+
+    def test_12(self):
+        # failure if kdf is missing
+        self.assertRaises(ValueError,
+                key_agreement,
+                static_pub=self.static_pub,
+                static_priv=self.static_priv)
+
+
+class X25519_Tests(unittest.TestCase):
+
+    def test_rfc7748_1(self):
+        tvs = (
+                ("a546e36bf0527c9d3b16154b82465edd62144c0ac1fc5a18506a2244ba449ac4",
+                 "e6db6867583030db3594c1a424b15f7c726624ec26b3353b10a903a6d0ab1c4c",
+                 "c3da55379de9c6908e94ea4df28d084f32eccf03491c71f754b4075577a28552"),
+                ("4b66e9d4d1b4673c5ad22691957d6af5c11b6421e0ea01d42ca4169e7918ba0d",
+                 "e5210f12786811d3f4b7959d0538ae2c31dbe7106fc03c3efc4cd549c715a493",
+                 "95cbde9476e8907d7aade45cb4b873f88b595a68799fa152e6f8f7647aac7957"),
+        )
+
+        for tv1, tv2, tv3 in tvs:
+            priv_key = DH.import_x25519_private_key(unhexlify(tv1))
+            pub_key = DH.import_x25519_public_key(unhexlify(tv2))
+            result = key_agreement(static_pub=pub_key,
+                                   static_priv=priv_key,
+                                   kdf=lambda x: x)
+            self.assertEqual(result, unhexlify(tv3))
+
+    def test_rfc7748_2(self):
+        k = unhexlify("0900000000000000000000000000000000000000000000000000000000000000")
+
+        priv_key = DH.import_x25519_private_key(k)
+        pub_key = DH.import_x25519_public_key(k)
+        result = key_agreement(static_pub=pub_key,
+                               static_priv=priv_key,
+                               kdf=lambda x: x)
+        self.assertEqual(
+            result,
+            unhexlify("422c8e7a6227d7bca1350b3e2bb7279f7897b87bb6854b783c60e80311ae3079")
+        )
+
+        for _ in range(999):
+            priv_key = DH.import_x25519_private_key(result)
+            pub_key = DH.import_x25519_public_key(k)
+            k = result
+            result = key_agreement(static_pub=pub_key,
+                                   static_priv=priv_key,
+                                   kdf=lambda x: x)
+
+        self.assertEqual(
+            result,
+            unhexlify("684cf59ba83309552800ef566f2f4d3c1c3887c49360e3875f2eb94d99532c51")
+        )
+
+    def test_rfc7748_3(self):
+        tv1 = "77076d0a7318a57d3c16c17251b26645df4c2f87ebc0992ab177fba51db92c2a"
+        tv2 = "8520f0098930a754748b7ddcb43ef75a0dbf3a0d26381af4eba4a98eaa9b4e6a"
+        tv3 = "5dab087e624a8a4b79e17f8b83800ee66f3bb1292618b6fd1c2f8b27ff88e0eb"
+        tv4 = "de9edb7d7b7dc1b4d35b61c2ece435373f8343c85b78674dadfc7e146f882b4f"
+        tv5 = "4a5d9d5ba4ce2de1728e3bf480350f25e07e21c947d19e3376f09b3c1e161742"
+
+        alice_priv_key = DH.import_x25519_private_key(unhexlify(tv1))
+        alice_pub_key = DH.import_x25519_public_key(unhexlify(tv2))
+        bob_priv_key = DH.import_x25519_private_key(unhexlify(tv3))
+        bob_pub_key = DH.import_x25519_public_key(unhexlify(tv4))
+        secret = unhexlify(tv5)
+
+        result1 = key_agreement(static_pub=alice_pub_key,
+                                static_priv=bob_priv_key,
+                                kdf=lambda x: x)
+        result2 = key_agreement(static_pub=bob_pub_key,
+                                static_priv=alice_priv_key,
+                                kdf=lambda x: x)
+        self.assertEqual(result1, secret)
+        self.assertEqual(result2, secret)
+
+    def test_weak(self):
+
+        weak_keys = (
+            "0000000000000000000000000000000000000000000000000000000000000000",
+            "0100000000000000000000000000000000000000000000000000000000000000",
+            "e0eb7a7c3b41b8ae1656e3faf19fc46ada098deb9c32b1fd866205165f49b800",
+            "5f9c95bca3508c24b1d0b1559c83ef5b04445cc4581c8e86d8224eddd09f1157",
+            "ecffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff7f",
+            "edffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff7f",
+            "eeffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff7f",
+            # The implementation will accept these value, but only because
+            # it will set the MSB to zero (as required by RFC7748, Section 5),
+            # therefore leading to another public key (and to a point which is
+            # not of low order anymore).
+            # "cdeb7a7c3b41b8ae1656e3faf19fc46ada098deb9c32b1fd866205165f49b880",
+            # "4c9c95bca3508c24b1d0b1559c83ef5b04445cc4581c8e86d8224eddd09f11d7",
+            # "d9ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff",
+            # "daffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff",
+            # "dbffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff",
+        )
+
+        for x in weak_keys:
+            self.assertRaises(ValueError,
+                              DH.import_x25519_public_key,
+                              unhexlify(x))
+
+
+class X448_Tests(unittest.TestCase):
+
+    def test_rfc7748_1(self):
+        tvs = (
+                ("3d262fddf9ec8e88495266fea19a34d28882acef045104d0d1aae121700a779c984c24f8cdd78fbff44943eba368f54b29259a4f1c600ad3",
+                 "06fce640fa3487bfda5f6cf2d5263f8aad88334cbd07437f020f08f9814dc031ddbdc38c19c6da2583fa5429db94ada18aa7a7fb4ef8a086",
+                 "ce3e4ff95a60dc6697da1db1d85e6afbdf79b50a2412d7546d5f239fe14fbaadeb445fc66a01b0779d98223961111e21766282f73dd96b6f"),
+                ("203d494428b8399352665ddca42f9de8fef600908e0d461cb021f8c538345dd77c3e4806e25f46d3315c44e0a5b4371282dd2c8d5be3095f",
+                 "0fbcc2f993cd56d3305b0b7d9e55d4c1a8fb5dbb52f8e9a1e9b6201b165d015894e56c4d3570bee52fe205e28a78b91cdfbde71ce8d157db",
+                 "884a02576239ff7a2f2f63b2db6a9ff37047ac13568e1e30fe63c4a7ad1b3ee3a5700df34321d62077e63633c575c1c954514e99da7c179d"),
+        )
+
+        for tv1, tv2, tv3 in tvs:
+            priv_key = DH.import_x448_private_key(unhexlify(tv1))
+            pub_key = DH.import_x448_public_key(unhexlify(tv2))
+            result = key_agreement(static_pub=pub_key,
+                                   static_priv=priv_key,
+                                   kdf=lambda x: x)
+            self.assertEqual(result, unhexlify(tv3))
+
+    def test_rfc7748_2(self):
+        k = unhexlify("0500000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000")
+
+        priv_key = DH.import_x448_private_key(k)
+        pub_key = DH.import_x448_public_key(k)
+        result = key_agreement(static_pub=pub_key,
+                               static_priv=priv_key,
+                               kdf=lambda x: x)
+        self.assertEqual(
+            result,
+            unhexlify("3f482c8a9f19b01e6c46ee9711d9dc14fd4bf67af30765c2ae2b846a4d23a8cd0db897086239492caf350b51f833868b9bc2b3bca9cf4113")
+        )
+
+        for _ in range(999):
+            priv_key = DH.import_x448_private_key(result)
+            pub_key = DH.import_x448_public_key(k)
+            k = result
+            result = key_agreement(static_pub=pub_key,
+                                   static_priv=priv_key,
+                                   kdf=lambda x: x)
+
+        self.assertEqual(
+            result,
+            unhexlify("aa3b4749d55b9daf1e5b00288826c467274ce3ebbdd5c17b975e09d4af6c67cf10d087202db88286e2b79fceea3ec353ef54faa26e219f38")
+        )
+
+    def test_rfc7748_3(self):
+        tv1 = "9a8f4925d1519f5775cf46b04b5800d4ee9ee8bae8bc5565d498c28dd9c9baf574a9419744897391006382a6f127ab1d9ac2d8c0a598726b"
+        tv2 = "9b08f7cc31b7e3e67d22d5aea121074a273bd2b83de09c63faa73d2c22c5d9bbc836647241d953d40c5b12da88120d53177f80e532c41fa0"
+        tv3 = "1c306a7ac2a0e2e0990b294470cba339e6453772b075811d8fad0d1d6927c120bb5ee8972b0d3e21374c9c921b09d1b0366f10b65173992d"
+        tv4 = "3eb7a829b0cd20f5bcfc0b599b6feccf6da4627107bdb0d4f345b43027d8b972fc3e34fb4232a13ca706dcb57aec3dae07bdc1c67bf33609"
+        tv5 = "07fff4181ac6cc95ec1c16a94a0f74d12da232ce40a77552281d282bb60c0b56fd2464c335543936521c24403085d59a449a5037514a879d"
+
+        alice_priv_key = DH.import_x448_private_key(unhexlify(tv1))
+        alice_pub_key = DH.import_x448_public_key(unhexlify(tv2))
+        bob_priv_key = DH.import_x448_private_key(unhexlify(tv3))
+        bob_pub_key = DH.import_x448_public_key(unhexlify(tv4))
+        secret = unhexlify(tv5)
+
+        result1 = key_agreement(static_pub=alice_pub_key,
+                                static_priv=bob_priv_key,
+                                kdf=lambda x: x)
+        result2 = key_agreement(static_pub=bob_pub_key,
+                                static_priv=alice_priv_key,
+                                kdf=lambda x: x)
+        self.assertEqual(result1, secret)
+        self.assertEqual(result2, secret)
+
+    def test_weak(self):
+
+        weak_keys = (
+            "0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000",
+            "0100000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000",
+            "fefffffffffffffffffffffffffffffffffffffffffffffffffffffffeffffffffffffffffffffffffffffffffffffffffffffffffffffff",
+            "fffffffffffffffffffffffffffffffffffffffffffffffffffffffffeffffffffffffffffffffffffffffffffffffffffffffffffffffff",
+            "00000000000000000000000000000000000000000000000000000000ffffffffffffffffffffffffffffffffffffffffffffffffffffffff",
+        )
+
+        for x in weak_keys:
+            self.assertRaises(ValueError,
+                              DH.import_x448_public_key,
+                              unhexlify(x))
+
+
+class TestVectorsXECDHWycheproof(unittest.TestCase):
+
+    desc = "Wycheproof XECDH tests"
+
+    def add_tests_hex(self, filename):
+
+        def encoding(g):
+            return g['type']
+
+        def private(u):
+            return unhexlify(u['private'])
+
+        result = load_test_vectors_wycheproof(("Protocol", "wycheproof"),
+                                              filename,
+                                              "Wycheproof ECDH (%s)"
+                                              % filename,
+                                              group_tag={'encoding': encoding},
+                                              unit_tag={'private': private}
+                                              )
+        self.tv += result
+
+    def add_tests_ascii(self, filename):
+
+        def encoding(g):
+            return g['type']
+
+        def public(u):
+            return u['public']
+
+        def private(u):
+            return u['private']
+
+        result = load_test_vectors_wycheproof(("Protocol", "wycheproof"),
+                                              filename,
+                                              "Wycheproof ECDH (%s)"
+                                              % filename,
+                                              group_tag={'encoding': encoding},
+                                              unit_tag={'public': public,
+                                                        'private': private}
+                                              )
+        self.tv += result
+
+    def setUp(self):
+        self.tv = []
+        self.desc = None
+
+        self.add_tests_hex("x25519_test.json")
+        self.add_tests_hex("x25519_asn_test.json")
+        self.add_tests_ascii("x25519_pem_test.json")
+        self.add_tests_ascii("x25519_jwk_test.json")
+
+    def shortDescription(self):
+        return self.desc
+
+    def test_verify(self, tv):
+
+        if tv.encoding == "XdhComp":
+            try:
+                public_key = import_x25519_public_key(tv.public)
+            except ValueError as e:
+                assert tv.valid
+                assert tv.warning
+                assert "LowOrderPublic" in tv.flags
+                assert "Invalid Curve25519" in str(e)
+                return
+            private_key = import_x25519_private_key(tv.private)
+        elif tv.encoding in ("XdhAsnComp", "XdhPemComp"):
+            try:
+                public_key = ECC.import_key(tv.public)
+                private_key = ECC.import_key(tv.private)
+            except ECC.UnsupportedEccFeature as e:
+                assert not tv.valid
+                assert "Unsupported ECC" in str(e)
+                return
+            except ValueError:
+                assert tv.valid
+                assert tv.warning
+                assert "LowOrderPublic" in tv.flags
+                return
+        elif tv.encoding == "XdhJwkComp":
+
+            if 'y' in tv.public:
+                return
+            if 'x' not in tv.public:
+                return
+            if 'x' not in tv.private:
+                return
+            if tv.public.get('kty') != 'OKP':
+                return
+            if tv.public.get('crv') != 'X25519':
+                return
+            if tv.private.get('crv') != 'X25519':
+                return
+
+            def base64url_decode(input_str):
+                input_str = input_str.replace('-', '+').replace('_', '/')
+                padding = 4 - (len(input_str) % 4)
+                if padding != 4:
+                    input_str += '=' * padding
+                decoded_bytes = base64.b64decode(input_str)
+                return decoded_bytes
+
+            jwk_public = base64url_decode(tv.public['x'])
+            jwk_private = base64url_decode(tv.private['d'])
+
+            try:
+                public_key = import_x25519_public_key(jwk_public)
+                private_key = import_x25519_private_key(jwk_private)
+            except ValueError as e:
+                if tv.valid:
+                    assert tv.warning
+                    assert "LowOrderPublic" in tv.flags
+                    assert "Invalid Curve25519" in str(e)
+                    return
+                else:
+                    assert "Incorrect length" in str(e)
+                    return
+            except ValueError:
+                assert tv.valid
+        else:
+            raise ValueError("Unknown encoding", tv.encoding)
+
+        try:
+            z = key_agreement(static_pub=public_key,
+                              static_priv=private_key,
+                              kdf=lambda x: x)
+        except ValueError:
+            assert not tv.valid
+        except TypeError as e:
+            assert not tv.valid
+            assert "incompatible curve" in str(e)
+        else:
+            self.assertEqual(z, tv.shared)
+            assert tv.valid
+
+    def runTest(self):
+        for tv in self.tv:
+            self.desc = "Wycheproof XECDH Verify Test #%d (%s, %s)" % (tv.id, tv.comment, tv.filename)
+            self.test_verify(tv)
+
+
+def get_tests(config={}):
+
+    tests = []
+    tests += list_test_cases(FIPS_ECDH_Tests_KAT)
+    tests += [TestVectorsECDHWycheproof()]
+    tests += list_test_cases(ECDH_Tests)
+    tests += list_test_cases(X25519_Tests)
+    tests += list_test_cases(X448_Tests)
+    tests += [TestVectorsXECDHWycheproof()]
+
+    slow_tests = config.get('slow_tests')
+    if slow_tests:
+        pass
+
+    return tests
+
+
+if __name__ == '__main__':
+    def suite():
+        return unittest.TestSuite(get_tests())
+    unittest.main(defaultTest='suite')