Add files using upload-large-folder tool

wemm/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)

wemm/lib/python3.10/site-packages/Crypto/Math/Numbers.py

@@ -0,0 +1,47 @@
+# ===================================================================
+#
+# 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__ = ["Integer"]
+
+import os
+
+try:
+    if os.getenv("PYCRYPTODOME_DISABLE_GMP"):
+        raise ImportError()
+
+    from Crypto.Math._IntegerGMP import IntegerGMP as Integer
+    from Crypto.Math._IntegerGMP import implementation as _implementation
+except (ImportError, OSError, AttributeError):
+    try:
+        from Crypto.Math._IntegerCustom import IntegerCustom as Integer
+        from Crypto.Math._IntegerCustom import implementation as _implementation
+    except (ImportError, OSError):
+        from Crypto.Math._IntegerNative import IntegerNative as Integer
+        _implementation = {}

wemm/lib/python3.10/site-packages/Crypto/Math/Numbers.pyi

@@ -0,0 +1,2 @@
+from Crypto.Math._IntegerBase import IntegerBase as Integer
+__all__ = ['Integer']

wemm/lib/python3.10/site-packages/Crypto/Math/Primality.py

@@ -0,0 +1,369 @@
+# ===================================================================
+#
+# 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.
+# ===================================================================
+
+"""Functions to create and test prime numbers.
+
+:undocumented: __package__
+"""
+
+from Crypto import Random
+from Crypto.Math.Numbers import Integer
+
+from Crypto.Util.py3compat import iter_range
+
+COMPOSITE = 0
+PROBABLY_PRIME = 1
+
+
+def miller_rabin_test(candidate, iterations, randfunc=None):
+    """Perform a Miller-Rabin primality test on an integer.
+
+    The test is specified in Section C.3.1 of `FIPS PUB 186-4`__.
+
+    :Parameters:
+      candidate : integer
+        The number to test for primality.
+      iterations : integer
+        The maximum number of iterations to perform before
+        declaring a candidate a probable prime.
+      randfunc : callable
+        An RNG function where bases are taken from.
+
+    :Returns:
+      ``Primality.COMPOSITE`` or ``Primality.PROBABLY_PRIME``.
+
+    .. __: http://nvlpubs.nist.gov/nistpubs/FIPS/NIST.FIPS.186-4.pdf
+    """
+
+    if not isinstance(candidate, Integer):
+        candidate = Integer(candidate)
+
+    if candidate in (1, 2, 3, 5):
+        return PROBABLY_PRIME
+
+    if candidate.is_even():
+        return COMPOSITE
+
+    one = Integer(1)
+    minus_one = Integer(candidate - 1)
+
+    if randfunc is None:
+        randfunc = Random.new().read
+
+    # Step 1 and 2
+    m = Integer(minus_one)
+    a = 0
+    while m.is_even():
+        m >>= 1
+        a += 1
+
+    # Skip step 3
+
+    # Step 4
+    for i in iter_range(iterations):
+
+        # Step 4.1-2
+        base = 1
+        while base in (one, minus_one):
+            base = Integer.random_range(min_inclusive=2,
+                    max_inclusive=candidate - 2,
+                    randfunc=randfunc)
+            assert(2 <= base <= candidate - 2)
+
+        # Step 4.3-4.4
+        z = pow(base, m, candidate)
+        if z in (one, minus_one):
+            continue
+
+        # Step 4.5
+        for j in iter_range(1, a):
+            z = pow(z, 2, candidate)
+            if z == minus_one:
+                break
+            if z == one:
+                return COMPOSITE
+        else:
+            return COMPOSITE
+
+    # Step 5
+    return PROBABLY_PRIME
+
+
+def lucas_test(candidate):
+    """Perform a Lucas primality test on an integer.
+
+    The test is specified in Section C.3.3 of `FIPS PUB 186-4`__.
+
+    :Parameters:
+      candidate : integer
+        The number to test for primality.
+
+    :Returns:
+      ``Primality.COMPOSITE`` or ``Primality.PROBABLY_PRIME``.
+
+    .. __: http://nvlpubs.nist.gov/nistpubs/FIPS/NIST.FIPS.186-4.pdf
+    """
+
+    if not isinstance(candidate, Integer):
+        candidate = Integer(candidate)
+
+    # Step 1
+    if candidate in (1, 2, 3, 5):
+        return PROBABLY_PRIME
+    if candidate.is_even() or candidate.is_perfect_square():
+        return COMPOSITE
+
+    # Step 2
+    def alternate():
+        value = 5
+        while True:
+            yield value
+            if value > 0:
+                value += 2
+            else:
+                value -= 2
+            value = -value
+
+    for D in alternate():
+        if candidate in (D, -D):
+            continue
+        js = Integer.jacobi_symbol(D, candidate)
+        if js == 0:
+            return COMPOSITE
+        if js == -1:
+            break
+    # Found D. P=1 and Q=(1-D)/4 (note that Q is guaranteed to be an integer)
+
+    # Step 3
+    # This is \delta(n) = n - jacobi(D/n)
+    K = candidate + 1
+    # Step 4
+    r = K.size_in_bits() - 1
+    # Step 5
+    # U_1=1 and V_1=P
+    U_i = Integer(1)
+    V_i = Integer(1)
+    U_temp = Integer(0)
+    V_temp = Integer(0)
+    # Step 6
+    for i in iter_range(r - 1, -1, -1):
+        # Square
+        # U_temp = U_i * V_i % candidate
+        U_temp.set(U_i)
+        U_temp *= V_i
+        U_temp %= candidate
+        # V_temp = (((V_i ** 2 + (U_i ** 2 * D)) * K) >> 1) % candidate
+        V_temp.set(U_i)
+        V_temp *= U_i
+        V_temp *= D
+        V_temp.multiply_accumulate(V_i, V_i)
+        if V_temp.is_odd():
+            V_temp += candidate
+        V_temp >>= 1
+        V_temp %= candidate
+        # Multiply
+        if K.get_bit(i):
+            # U_i = (((U_temp + V_temp) * K) >> 1) % candidate
+            U_i.set(U_temp)
+            U_i += V_temp
+            if U_i.is_odd():
+                U_i += candidate
+            U_i >>= 1
+            U_i %= candidate
+            # V_i = (((V_temp + U_temp * D) * K) >> 1) % candidate
+            V_i.set(V_temp)
+            V_i.multiply_accumulate(U_temp, D)
+            if V_i.is_odd():
+                V_i += candidate
+            V_i >>= 1
+            V_i %= candidate
+        else:
+            U_i.set(U_temp)
+            V_i.set(V_temp)
+    # Step 7
+    if U_i == 0:
+        return PROBABLY_PRIME
+    return COMPOSITE
+
+
+from Crypto.Util.number import sieve_base as _sieve_base_large
+## The optimal number of small primes to use for the sieve
+## is probably dependent on the platform and the candidate size
+_sieve_base = set(_sieve_base_large[:100])
+
+
+def test_probable_prime(candidate, randfunc=None):
+    """Test if a number is prime.
+
+    A number is qualified as prime if it passes a certain
+    number of Miller-Rabin tests (dependent on the size
+    of the number, but such that probability of a false
+    positive is less than 10^-30) and a single Lucas test.
+
+    For instance, a 1024-bit candidate will need to pass
+    4 Miller-Rabin tests.
+
+    :Parameters:
+      candidate : integer
+        The number to test for primality.
+      randfunc : callable
+        The routine to draw random bytes from to select Miller-Rabin bases.
+    :Returns:
+      ``PROBABLE_PRIME`` if the number if prime with very high probability.
+      ``COMPOSITE`` if the number is a composite.
+      For efficiency reasons, ``COMPOSITE`` is also returned for small primes.
+    """
+
+    if randfunc is None:
+        randfunc = Random.new().read
+
+    if not isinstance(candidate, Integer):
+        candidate = Integer(candidate)
+
+    # First, check trial division by the smallest primes
+    if int(candidate) in _sieve_base:
+        return PROBABLY_PRIME
+    try:
+        map(candidate.fail_if_divisible_by, _sieve_base)
+    except ValueError:
+        return COMPOSITE
+
+    # These are the number of Miller-Rabin iterations s.t. p(k, t) < 1E-30,
+    # with p(k, t) being the probability that a randomly chosen k-bit number
+    # is composite but still survives t MR iterations.
+    mr_ranges = ((220, 30), (280, 20), (390, 15), (512, 10),
+                 (620, 7), (740, 6), (890, 5), (1200, 4),
+                 (1700, 3), (3700, 2))
+
+    bit_size = candidate.size_in_bits()
+    try:
+        mr_iterations = list(filter(lambda x: bit_size < x[0],
+                                    mr_ranges))[0][1]
+    except IndexError:
+        mr_iterations = 1
+
+    if miller_rabin_test(candidate, mr_iterations,
+                         randfunc=randfunc) == COMPOSITE:
+        return COMPOSITE
+    if lucas_test(candidate) == COMPOSITE:
+        return COMPOSITE
+    return PROBABLY_PRIME
+
+
+def generate_probable_prime(**kwargs):
+    """Generate a random probable prime.
+
+    The prime will not have any specific properties
+    (e.g. it will not be a *strong* prime).
+
+    Random numbers are evaluated for primality until one
+    passes all tests, consisting of a certain number of
+    Miller-Rabin tests with random bases followed by
+    a single Lucas test.
+
+    The number of Miller-Rabin iterations is chosen such that
+    the probability that the output number is a non-prime is
+    less than 1E-30 (roughly 2^{-100}).
+
+    This approach is compliant to `FIPS PUB 186-4`__.
+
+    :Keywords:
+      exact_bits : integer
+        The desired size in bits of the probable prime.
+        It must be at least 160.
+      randfunc : callable
+        An RNG function where candidate primes are taken from.
+      prime_filter : callable
+        A function that takes an Integer as parameter and returns
+        True if the number can be passed to further primality tests,
+        False if it should be immediately discarded.
+
+    :Return:
+        A probable prime in the range 2^exact_bits > p > 2^(exact_bits-1).
+
+    .. __: http://nvlpubs.nist.gov/nistpubs/FIPS/NIST.FIPS.186-4.pdf
+    """
+
+    exact_bits = kwargs.pop("exact_bits", None)
+    randfunc = kwargs.pop("randfunc", None)
+    prime_filter = kwargs.pop("prime_filter", lambda x: True)
+    if kwargs:
+        raise ValueError("Unknown parameters: " + kwargs.keys())
+
+    if exact_bits is None:
+        raise ValueError("Missing exact_bits parameter")
+    if exact_bits < 160:
+        raise ValueError("Prime number is not big enough.")
+
+    if randfunc is None:
+        randfunc = Random.new().read
+
+    result = COMPOSITE
+    while result == COMPOSITE:
+        candidate = Integer.random(exact_bits=exact_bits,
+                                   randfunc=randfunc) | 1
+        if not prime_filter(candidate):
+            continue
+        result = test_probable_prime(candidate, randfunc)
+    return candidate
+
+
+def generate_probable_safe_prime(**kwargs):
+    """Generate a random, probable safe prime.
+
+    Note this operation is much slower than generating a simple prime.
+
+    :Keywords:
+      exact_bits : integer
+        The desired size in bits of the probable safe prime.
+      randfunc : callable
+        An RNG function where candidate primes are taken from.
+
+    :Return:
+        A probable safe prime in the range
+        2^exact_bits > p > 2^(exact_bits-1).
+    """
+
+    exact_bits = kwargs.pop("exact_bits", None)
+    randfunc = kwargs.pop("randfunc", None)
+    if kwargs:
+        raise ValueError("Unknown parameters: " + kwargs.keys())
+
+    if randfunc is None:
+        randfunc = Random.new().read
+
+    result = COMPOSITE
+    while result == COMPOSITE:
+        q = generate_probable_prime(exact_bits=exact_bits - 1, randfunc=randfunc)
+        candidate = q * 2 + 1
+        if candidate.size_in_bits() != exact_bits:
+            continue
+        result = test_probable_prime(candidate, randfunc=randfunc)
+    return candidate

wemm/lib/python3.10/site-packages/Crypto/Math/Primality.pyi

@@ -0,0 +1,18 @@
+from typing import Callable, Optional, Union, Set
+
+PrimeResult = int
+
+COMPOSITE: PrimeResult
+PROBABLY_PRIME: PrimeResult
+
+def miller_rabin_test(candidate: int, iterations: int, randfunc: Optional[Callable[[int],bytes]]=None) -> PrimeResult: ...
+def lucas_test(candidate: int) -> PrimeResult: ...
+_sieve_base: Set[int]
+def test_probable_prime(candidate: int, randfunc: Optional[Callable[[int],bytes]]=None) -> PrimeResult: ...
+def generate_probable_prime(*,
+                            exact_bits: int = ...,
+                            randfunc: Callable[[int],bytes] = ...,
+                            prime_filter: Callable[[int],bool] = ...) -> int: ...
+def generate_probable_safe_prime(*,
+                            exact_bits: int = ...,
+                            randfunc: Callable[[int],bytes] = ...) -> int: ...

wemm/lib/python3.10/site-packages/Crypto/Math/_IntegerBase.py

@@ -0,0 +1,412 @@
+# ===================================================================
+#
+# Copyright (c) 2018, 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.
+# ===================================================================
+
+import abc
+
+from Crypto.Util.py3compat import iter_range, bord, bchr, ABC
+
+from Crypto import Random
+
+
+class IntegerBase(ABC):
+
+    # Conversions
+    @abc.abstractmethod
+    def __int__(self):
+        pass
+
+    @abc.abstractmethod
+    def __str__(self):
+        pass
+
+    @abc.abstractmethod
+    def __repr__(self):
+        pass
+
+    @abc.abstractmethod
+    def to_bytes(self, block_size=0, byteorder='big'):
+        pass
+
+    @staticmethod
+    @abc.abstractmethod
+    def from_bytes(byte_string, byteorder='big'):
+        pass
+
+    # Relations
+    @abc.abstractmethod
+    def __eq__(self, term):
+        pass
+
+    @abc.abstractmethod
+    def __ne__(self, term):
+        pass
+
+    @abc.abstractmethod
+    def __lt__(self, term):
+        pass
+
+    @abc.abstractmethod
+    def __le__(self, term):
+        pass
+
+    @abc.abstractmethod
+    def __gt__(self, term):
+        pass
+
+    @abc.abstractmethod
+    def __ge__(self, term):
+        pass
+
+    @abc.abstractmethod
+    def __nonzero__(self):
+        pass
+    __bool__ = __nonzero__
+
+    @abc.abstractmethod
+    def is_negative(self):
+        pass
+
+    # Arithmetic operations
+    @abc.abstractmethod
+    def __add__(self, term):
+        pass
+
+    @abc.abstractmethod
+    def __sub__(self, term):
+        pass
+
+    @abc.abstractmethod
+    def __mul__(self, factor):
+        pass
+
+    @abc.abstractmethod
+    def __floordiv__(self, divisor):
+        pass
+
+    @abc.abstractmethod
+    def __mod__(self, divisor):
+        pass
+
+    @abc.abstractmethod
+    def inplace_pow(self, exponent, modulus=None):
+        pass
+
+    @abc.abstractmethod
+    def __pow__(self, exponent, modulus=None):
+        pass
+
+    @abc.abstractmethod
+    def __abs__(self):
+        pass
+
+    @abc.abstractmethod
+    def sqrt(self, modulus=None):
+        pass
+
+    @abc.abstractmethod
+    def __iadd__(self, term):
+        pass
+
+    @abc.abstractmethod
+    def __isub__(self, term):
+        pass
+
+    @abc.abstractmethod
+    def __imul__(self, term):
+        pass
+
+    @abc.abstractmethod
+    def __imod__(self, term):
+        pass
+
+    # Boolean/bit operations
+    @abc.abstractmethod
+    def __and__(self, term):
+        pass
+
+    @abc.abstractmethod
+    def __or__(self, term):
+        pass
+
+    @abc.abstractmethod
+    def __rshift__(self, pos):
+        pass
+
+    @abc.abstractmethod
+    def __irshift__(self, pos):
+        pass
+
+    @abc.abstractmethod
+    def __lshift__(self, pos):
+        pass
+
+    @abc.abstractmethod
+    def __ilshift__(self, pos):
+        pass
+
+    @abc.abstractmethod
+    def get_bit(self, n):
+        pass
+
+    # Extra
+    @abc.abstractmethod
+    def is_odd(self):
+        pass
+
+    @abc.abstractmethod
+    def is_even(self):
+        pass
+
+    @abc.abstractmethod
+    def size_in_bits(self):
+        pass
+
+    @abc.abstractmethod
+    def size_in_bytes(self):
+        pass
+
+    @abc.abstractmethod
+    def is_perfect_square(self):
+        pass
+
+    @abc.abstractmethod
+    def fail_if_divisible_by(self, small_prime):
+        pass
+
+    @abc.abstractmethod
+    def multiply_accumulate(self, a, b):
+        pass
+
+    @abc.abstractmethod
+    def set(self, source):
+        pass
+
+    @abc.abstractmethod
+    def inplace_inverse(self, modulus):
+        pass
+
+    @abc.abstractmethod
+    def inverse(self, modulus):
+        pass
+
+    @abc.abstractmethod
+    def gcd(self, term):
+        pass
+
+    @abc.abstractmethod
+    def lcm(self, term):
+        pass
+
+    @staticmethod
+    @abc.abstractmethod
+    def jacobi_symbol(a, n):
+        pass
+
+    @staticmethod
+    def _tonelli_shanks(n, p):
+        """Tonelli-shanks algorithm for computing the square root
+        of n modulo a prime p.
+
+        n must be in the range [0..p-1].
+        p must be at least even.
+
+        The return value r is the square root of modulo p. If non-zero,
+        another solution will also exist (p-r).
+
+        Note we cannot assume that p is really a prime: if it's not,
+        we can either raise an exception or return the correct value.
+        """
+
+        # See https://rosettacode.org/wiki/Tonelli-Shanks_algorithm
+
+        if n in (0, 1):
+            return n
+
+        if p % 4 == 3:
+            root = pow(n, (p + 1) // 4, p)
+            if pow(root, 2, p) != n:
+                raise ValueError("Cannot compute square root")
+            return root
+
+        s = 1
+        q = (p - 1) // 2
+        while not (q & 1):
+            s += 1
+            q >>= 1
+
+        z = n.__class__(2)
+        while True:
+            euler = pow(z, (p - 1) // 2, p)
+            if euler == 1:
+                z += 1
+                continue
+            if euler == p - 1:
+                break
+            # Most probably p is not a prime
+            raise ValueError("Cannot compute square root")
+
+        m = s
+        c = pow(z, q, p)
+        t = pow(n, q, p)
+        r = pow(n, (q + 1) // 2, p)
+
+        while t != 1:
+            for i in iter_range(0, m):
+                if pow(t, 2**i, p) == 1:
+                    break
+            if i == m:
+                raise ValueError("Cannot compute square root of %d mod %d" % (n, p))
+            b = pow(c, 2**(m - i - 1), p)
+            m = i
+            c = b**2 % p
+            t = (t * b**2) % p
+            r = (r * b) % p
+
+        if pow(r, 2, p) != n:
+            raise ValueError("Cannot compute square root")
+
+        return r
+
+    @classmethod
+    def random(cls, **kwargs):
+        """Generate a random natural integer of a certain size.
+
+        :Keywords:
+          exact_bits : positive integer
+            The length in bits of the resulting random Integer number.
+            The number is guaranteed to fulfil the relation:
+
+                2^bits > result >= 2^(bits - 1)
+
+          max_bits : positive integer
+            The maximum length in bits of the resulting random Integer number.
+            The number is guaranteed to fulfil the relation:
+
+                2^bits > result >=0
+
+          randfunc : callable
+            A function that returns a random byte string. The length of the
+            byte string is passed as parameter. Optional.
+            If not provided (or ``None``), randomness is read from the system RNG.
+
+        :Return: a Integer object
+        """
+
+        exact_bits = kwargs.pop("exact_bits", None)
+        max_bits = kwargs.pop("max_bits", None)
+        randfunc = kwargs.pop("randfunc", None)
+
+        if randfunc is None:
+            randfunc = Random.new().read
+
+        if exact_bits is None and max_bits is None:
+            raise ValueError("Either 'exact_bits' or 'max_bits' must be specified")
+
+        if exact_bits is not None and max_bits is not None:
+            raise ValueError("'exact_bits' and 'max_bits' are mutually exclusive")
+
+        bits = exact_bits or max_bits
+        bytes_needed = ((bits - 1) // 8) + 1
+        significant_bits_msb = 8 - (bytes_needed * 8 - bits)
+        msb = bord(randfunc(1)[0])
+        if exact_bits is not None:
+            msb |= 1 << (significant_bits_msb - 1)
+        msb &= (1 << significant_bits_msb) - 1
+
+        return cls.from_bytes(bchr(msb) + randfunc(bytes_needed - 1))
+
+    @classmethod
+    def random_range(cls, **kwargs):
+        """Generate a random integer within a given internal.
+
+        :Keywords:
+          min_inclusive : integer
+            The lower end of the interval (inclusive).
+          max_inclusive : integer
+            The higher end of the interval (inclusive).
+          max_exclusive : integer
+            The higher end of the interval (exclusive).
+          randfunc : callable
+            A function that returns a random byte string. The length of the
+            byte string is passed as parameter. Optional.
+            If not provided (or ``None``), randomness is read from the system RNG.
+        :Returns:
+            An Integer randomly taken in the given interval.
+        """
+
+        min_inclusive = kwargs.pop("min_inclusive", None)
+        max_inclusive = kwargs.pop("max_inclusive", None)
+        max_exclusive = kwargs.pop("max_exclusive", None)
+        randfunc = kwargs.pop("randfunc", None)
+
+        if kwargs:
+            raise ValueError("Unknown keywords: " + str(kwargs.keys))
+        if None not in (max_inclusive, max_exclusive):
+            raise ValueError("max_inclusive and max_exclusive cannot be both"
+                         " specified")
+        if max_exclusive is not None:
+            max_inclusive = max_exclusive - 1
+        if None in (min_inclusive, max_inclusive):
+            raise ValueError("Missing keyword to identify the interval")
+
+        if randfunc is None:
+            randfunc = Random.new().read
+
+        norm_maximum = max_inclusive - min_inclusive
+        bits_needed = cls(norm_maximum).size_in_bits()
+
+        norm_candidate = -1
+        while not 0 <= norm_candidate <= norm_maximum:
+            norm_candidate = cls.random(
+                                    max_bits=bits_needed,
+                                    randfunc=randfunc
+                                    )
+        return norm_candidate + min_inclusive
+
+    @staticmethod
+    @abc.abstractmethod
+    def _mult_modulo_bytes(term1, term2, modulus):
+        """Multiply two integers, take the modulo, and encode as big endian.
+        This specialized method is used for RSA decryption.
+
+        Args:
+          term1 : integer
+            The first term of the multiplication, non-negative.
+          term2 : integer
+            The second term of the multiplication, non-negative.
+          modulus: integer
+            The modulus, a positive odd number.
+        :Returns:
+            A byte string, with the result of the modular multiplication
+            encoded in big endian mode.
+            It is as long as the modulus would be, with zero padding
+            on the left if needed.
+        """
+        pass

wemm/lib/python3.10/site-packages/Crypto/Math/_IntegerBase.pyi

@@ -0,0 +1,67 @@
+from typing import Optional, Union, Callable
+
+RandFunc = Callable[[int],int]
+
+class IntegerBase:
+
+    def __init__(self, value: Union[IntegerBase, int]): ...
+
+    def __int__(self) -> int: ...
+    def __str__(self) -> str: ...
+    def __repr__(self) -> str: ...
+    def to_bytes(self, block_size: Optional[int]=0, byteorder: str= ...) -> bytes: ...
+    @staticmethod
+    def from_bytes(byte_string: bytes, byteorder: Optional[str] = ...) -> IntegerBase: ...
+    def __eq__(self, term: object) -> bool: ...
+    def __ne__(self, term: object) -> bool: ...
+    def __lt__(self, term: Union[IntegerBase, int]) -> bool: ...
+    def __le__(self, term: Union[IntegerBase, int]) -> bool: ...
+    def __gt__(self, term: Union[IntegerBase, int]) -> bool: ...
+    def __ge__(self, term: Union[IntegerBase, int]) -> bool: ...
+    def __nonzero__(self) -> bool: ...
+    def is_negative(self) -> bool: ...
+    def __add__(self, term: Union[IntegerBase, int]) -> IntegerBase: ...
+    def __sub__(self, term: Union[IntegerBase, int]) -> IntegerBase: ...
+    def __mul__(self, term: Union[IntegerBase, int]) -> IntegerBase: ...
+    def __floordiv__(self, divisor: Union[IntegerBase, int]) -> IntegerBase: ...
+    def __mod__(self, divisor: Union[IntegerBase, int]) -> IntegerBase: ...
+    def inplace_pow(self, exponent: int, modulus: Optional[Union[IntegerBase, int]]=None) -> IntegerBase: ...
+    def __pow__(self, exponent: int, modulus: Optional[int]) -> IntegerBase: ...
+    def __abs__(self) -> IntegerBase: ...
+    def sqrt(self, modulus: Optional[int]) -> IntegerBase: ...
+    def __iadd__(self, term: Union[IntegerBase, int]) -> IntegerBase: ...
+    def __isub__(self, term: Union[IntegerBase, int]) -> IntegerBase: ...
+    def __imul__(self, term: Union[IntegerBase, int]) -> IntegerBase: ...
+    def __imod__(self, divisor: Union[IntegerBase, int]) -> IntegerBase: ...
+    def __and__(self, term: Union[IntegerBase, int]) -> IntegerBase: ...
+    def __or__(self, term: Union[IntegerBase, int]) -> IntegerBase: ...
+    def __rshift__(self, pos: Union[IntegerBase, int]) -> IntegerBase: ...
+    def __irshift__(self, pos: Union[IntegerBase, int]) -> IntegerBase: ...
+    def __lshift__(self, pos: Union[IntegerBase, int]) -> IntegerBase: ...
+    def __ilshift__(self, pos: Union[IntegerBase, int]) -> IntegerBase: ...
+    def get_bit(self, n: int) -> bool: ...
+    def is_odd(self) -> bool: ...
+    def is_even(self) -> bool: ...
+    def size_in_bits(self) -> int: ...
+    def size_in_bytes(self) -> int: ...
+    def is_perfect_square(self) -> bool: ...
+    def fail_if_divisible_by(self, small_prime: Union[IntegerBase, int]) -> None: ...
+    def multiply_accumulate(self, a: Union[IntegerBase, int], b: Union[IntegerBase, int]) -> IntegerBase: ...
+    def set(self, source: Union[IntegerBase, int]) -> IntegerBase: ...
+    def inplace_inverse(self, modulus: Union[IntegerBase, int]) -> IntegerBase: ...
+    def inverse(self, modulus: Union[IntegerBase, int]) -> IntegerBase: ...
+    def gcd(self, term: Union[IntegerBase, int]) -> IntegerBase: ...
+    def lcm(self, term: Union[IntegerBase, int]) -> IntegerBase: ...
+    @staticmethod
+    def jacobi_symbol(a: Union[IntegerBase, int], n: Union[IntegerBase, int]) -> IntegerBase: ...
+    @staticmethod
+    def _tonelli_shanks(n: Union[IntegerBase, int], p: Union[IntegerBase, int]) -> IntegerBase : ...
+    @classmethod
+    def random(cls, **kwargs: Union[int,RandFunc]) -> IntegerBase : ...
+    @classmethod
+    def random_range(cls, **kwargs: Union[int,RandFunc]) -> IntegerBase : ...
+    @staticmethod
+    def _mult_modulo_bytes(term1: Union[IntegerBase, int],
+                           term2:  Union[IntegerBase, int],
+                           modulus: Union[IntegerBase, int]) -> bytes: ...
+

wemm/lib/python3.10/site-packages/Crypto/Math/_IntegerCustom.py

@@ -0,0 +1,162 @@
+# ===================================================================
+#
+# Copyright (c) 2018, 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.
+# ===================================================================
+
+from ._IntegerNative import IntegerNative
+
+from Crypto.Util.number import long_to_bytes, bytes_to_long
+
+from Crypto.Util._raw_api import (load_pycryptodome_raw_lib,
+                                  create_string_buffer,
+                                  get_raw_buffer, backend,
+                                  c_size_t, c_ulonglong)
+
+
+from Crypto.Random.random import getrandbits
+
+c_defs = """
+int monty_pow(uint8_t       *out,
+              const uint8_t *base,
+              const uint8_t *exp,
+              const uint8_t *modulus,
+              size_t        len,
+              uint64_t      seed);
+
+int monty_multiply(uint8_t       *out,
+                   const uint8_t *term1,
+                   const uint8_t *term2,
+                   const uint8_t *modulus,
+                   size_t        len);
+"""
+
+
+_raw_montgomery = load_pycryptodome_raw_lib("Crypto.Math._modexp", c_defs)
+implementation = {"library": "custom", "api": backend}
+
+
+class IntegerCustom(IntegerNative):
+
+    @staticmethod
+    def from_bytes(byte_string, byteorder='big'):
+        if byteorder == 'big':
+            pass
+        elif byteorder == 'little':
+            byte_string = bytearray(byte_string)
+            byte_string.reverse()
+        else:
+            raise ValueError("Incorrect byteorder")
+        return IntegerCustom(bytes_to_long(byte_string))
+
+    def inplace_pow(self, exponent, modulus=None):
+        exp_value = int(exponent)
+        if exp_value < 0:
+            raise ValueError("Exponent must not be negative")
+
+        # No modular reduction
+        if modulus is None:
+            self._value = pow(self._value, exp_value)
+            return self
+
+        # With modular reduction
+        mod_value = int(modulus)
+        if mod_value < 0:
+            raise ValueError("Modulus must be positive")
+        if mod_value == 0:
+            raise ZeroDivisionError("Modulus cannot be zero")
+
+        # C extension only works with odd moduli
+        if (mod_value & 1) == 0:
+            self._value = pow(self._value, exp_value, mod_value)
+            return self
+
+        # C extension only works with bases smaller than modulus
+        if self._value >= mod_value:
+            self._value %= mod_value
+
+        max_len = len(long_to_bytes(max(self._value, exp_value, mod_value)))
+
+        base_b = long_to_bytes(self._value, max_len)
+        exp_b = long_to_bytes(exp_value, max_len)
+        modulus_b = long_to_bytes(mod_value, max_len)
+
+        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(getrandbits(64))
+                    )
+
+        if error:
+            raise ValueError("monty_pow failed with error: %d" % error)
+
+        result = bytes_to_long(get_raw_buffer(out))
+        self._value = result
+        return self
+
+    @staticmethod
+    def _mult_modulo_bytes(term1, term2, modulus):
+
+        # With modular reduction
+        mod_value = int(modulus)
+        if mod_value < 0:
+            raise ValueError("Modulus must be positive")
+        if mod_value == 0:
+            raise ZeroDivisionError("Modulus cannot be zero")
+
+        # C extension only works with odd moduli
+        if (mod_value & 1) == 0:
+            raise ValueError("Odd modulus is required")
+
+        # C extension only works with non-negative terms smaller than modulus
+        if term1 >= mod_value or term1 < 0:
+            term1 %= mod_value
+        if term2 >= mod_value or term2 < 0:
+            term2 %= mod_value
+
+        modulus_b = long_to_bytes(mod_value)
+        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:
+            raise ValueError("monty_multiply failed with error: %d" % error)
+
+        return get_raw_buffer(out)

wemm/lib/python3.10/site-packages/Crypto/Math/_IntegerNative.py

@@ -0,0 +1,382 @@
+# ===================================================================
+#
+# 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 ._IntegerBase import IntegerBase
+
+from Crypto.Util.number import long_to_bytes, bytes_to_long, inverse, GCD
+
+
+class IntegerNative(IntegerBase):
+    """A class to model a natural integer (including zero)"""
+
+    def __init__(self, value):
+        if isinstance(value, float):
+            raise ValueError("A floating point type is not a natural number")
+        try:
+            self._value = value._value
+        except AttributeError:
+            self._value = value
+
+    # Conversions
+    def __int__(self):
+        return self._value
+
+    def __str__(self):
+        return str(int(self))
+
+    def __repr__(self):
+        return "Integer(%s)" % str(self)
+
+    # Only Python 2.x
+    def __hex__(self):
+        return hex(self._value)
+
+    # Only Python 3.x
+    def __index__(self):
+        return int(self._value)
+
+    def to_bytes(self, block_size=0, byteorder='big'):
+        if self._value < 0:
+            raise ValueError("Conversion only valid for non-negative numbers")
+        result = long_to_bytes(self._value, block_size)
+        if len(result) > block_size > 0:
+            raise ValueError("Value too large to encode")
+        if byteorder == 'big':
+            pass
+        elif byteorder == 'little':
+            result = bytearray(result)
+            result.reverse()
+            result = bytes(result)
+        else:
+            raise ValueError("Incorrect byteorder")
+        return result
+
+    @classmethod
+    def from_bytes(cls, byte_string, byteorder='big'):
+        if byteorder == 'big':
+            pass
+        elif byteorder == 'little':
+            byte_string = bytearray(byte_string)
+            byte_string.reverse()
+        else:
+            raise ValueError("Incorrect byteorder")
+        return cls(bytes_to_long(byte_string))
+
+    # Relations
+    def __eq__(self, term):
+        if term is None:
+            return False
+        return self._value == int(term)
+
+    def __ne__(self, term):
+        return not self.__eq__(term)
+
+    def __lt__(self, term):
+        return self._value < int(term)
+
+    def __le__(self, term):
+        return self.__lt__(term) or self.__eq__(term)
+
+    def __gt__(self, term):
+        return not self.__le__(term)
+
+    def __ge__(self, term):
+        return not self.__lt__(term)
+
+    def __nonzero__(self):
+        return self._value != 0
+    __bool__ = __nonzero__
+
+    def is_negative(self):
+        return self._value < 0
+
+    # Arithmetic operations
+    def __add__(self, term):
+        try:
+            return self.__class__(self._value + int(term))
+        except (ValueError, AttributeError, TypeError):
+            return NotImplemented
+
+    def __sub__(self, term):
+        try:
+            return self.__class__(self._value - int(term))
+        except (ValueError, AttributeError, TypeError):
+            return NotImplemented
+
+    def __mul__(self, factor):
+        try:
+            return self.__class__(self._value * int(factor))
+        except (ValueError, AttributeError, TypeError):
+            return NotImplemented
+
+    def __floordiv__(self, divisor):
+        return self.__class__(self._value // int(divisor))
+
+    def __mod__(self, divisor):
+        divisor_value = int(divisor)
+        if divisor_value < 0:
+            raise ValueError("Modulus must be positive")
+        return self.__class__(self._value % divisor_value)
+
+    def inplace_pow(self, exponent, modulus=None):
+        exp_value = int(exponent)
+        if exp_value < 0:
+            raise ValueError("Exponent must not be negative")
+
+        if modulus is not None:
+            mod_value = int(modulus)
+            if mod_value < 0:
+                raise ValueError("Modulus must be positive")
+            if mod_value == 0:
+                raise ZeroDivisionError("Modulus cannot be zero")
+        else:
+            mod_value = None
+        self._value = pow(self._value, exp_value, mod_value)
+        return self
+
+    def __pow__(self, exponent, modulus=None):
+        result = self.__class__(self)
+        return result.inplace_pow(exponent, modulus)
+
+    def __abs__(self):
+        return abs(self._value)
+
+    def sqrt(self, modulus=None):
+
+        value = self._value
+        if modulus is None:
+            if value < 0:
+                raise ValueError("Square root of negative value")
+            # http://stackoverflow.com/questions/15390807/integer-square-root-in-python
+
+            x = value
+            y = (x + 1) // 2
+            while y < x:
+                x = y
+                y = (x + value // x) // 2
+            result = x
+        else:
+            if modulus <= 0:
+                raise ValueError("Modulus must be positive")
+            result = self._tonelli_shanks(self % modulus, modulus)
+
+        return self.__class__(result)
+
+    def __iadd__(self, term):
+        self._value += int(term)
+        return self
+
+    def __isub__(self, term):
+        self._value -= int(term)
+        return self
+
+    def __imul__(self, term):
+        self._value *= int(term)
+        return self
+
+    def __imod__(self, term):
+        modulus = int(term)
+        if modulus == 0:
+            raise ZeroDivisionError("Division by zero")
+        if modulus < 0:
+            raise ValueError("Modulus must be positive")
+        self._value %= modulus
+        return self
+
+    # Boolean/bit operations
+    def __and__(self, term):
+        return self.__class__(self._value & int(term))
+
+    def __or__(self, term):
+        return self.__class__(self._value | int(term))
+
+    def __rshift__(self, pos):
+        try:
+            return self.__class__(self._value >> int(pos))
+        except OverflowError:
+            if self._value >= 0:
+                return 0
+            else:
+                return -1
+
+    def __irshift__(self, pos):
+        try:
+            self._value >>= int(pos)
+        except OverflowError:
+            if self._value >= 0:
+                return 0
+            else:
+                return -1
+        return self
+
+    def __lshift__(self, pos):
+        try:
+            return self.__class__(self._value << int(pos))
+        except OverflowError:
+            raise ValueError("Incorrect shift count")
+
+    def __ilshift__(self, pos):
+        try:
+            self._value <<= int(pos)
+        except OverflowError:
+            raise ValueError("Incorrect shift count")
+        return self
+
+    def get_bit(self, n):
+        if self._value < 0:
+            raise ValueError("no bit representation for negative values")
+        try:
+            try:
+                result = (self._value >> n._value) & 1
+                if n._value < 0:
+                    raise ValueError("negative bit count")
+            except AttributeError:
+                result = (self._value >> n) & 1
+                if n < 0:
+                    raise ValueError("negative bit count")
+        except OverflowError:
+            result = 0
+        return result
+
+    # Extra
+    def is_odd(self):
+        return (self._value & 1) == 1
+
+    def is_even(self):
+        return (self._value & 1) == 0
+
+    def size_in_bits(self):
+
+        if self._value < 0:
+            raise ValueError("Conversion only valid for non-negative numbers")
+
+        if self._value == 0:
+            return 1
+
+        return self._value.bit_length()
+
+    def size_in_bytes(self):
+        return (self.size_in_bits() - 1) // 8 + 1
+
+    def is_perfect_square(self):
+        if self._value < 0:
+            return False
+        if self._value in (0, 1):
+            return True
+
+        x = self._value // 2
+        square_x = x ** 2
+
+        while square_x > self._value:
+            x = (square_x + self._value) // (2 * x)
+            square_x = x ** 2
+
+        return self._value == x ** 2
+
+    def fail_if_divisible_by(self, small_prime):
+        if (self._value % int(small_prime)) == 0:
+            raise ValueError("Value is composite")
+
+    def multiply_accumulate(self, a, b):
+        self._value += int(a) * int(b)
+        return self
+
+    def set(self, source):
+        self._value = int(source)
+
+    def inplace_inverse(self, modulus):
+        self._value = inverse(self._value, int(modulus))
+        return self
+
+    def inverse(self, modulus):
+        result = self.__class__(self)
+        result.inplace_inverse(modulus)
+        return result
+
+    def gcd(self, term):
+        return self.__class__(GCD(abs(self._value), abs(int(term))))
+
+    def lcm(self, term):
+        term = int(term)
+        if self._value == 0 or term == 0:
+            return self.__class__(0)
+        return self.__class__(abs((self._value * term) // self.gcd(term)._value))
+
+    @staticmethod
+    def jacobi_symbol(a, n):
+        a = int(a)
+        n = int(n)
+
+        if n <= 0:
+            raise ValueError("n must be a positive integer")
+
+        if (n & 1) == 0:
+            raise ValueError("n must be odd for the Jacobi symbol")
+
+        # Step 1
+        a = a % n
+        # Step 2
+        if a == 1 or n == 1:
+            return 1
+        # Step 3
+        if a == 0:
+            return 0
+        # Step 4
+        e = 0
+        a1 = a
+        while (a1 & 1) == 0:
+            a1 >>= 1
+            e += 1
+        # Step 5
+        if (e & 1) == 0:
+            s = 1
+        elif n % 8 in (1, 7):
+            s = 1
+        else:
+            s = -1
+        # Step 6
+        if n % 4 == 3 and a1 % 4 == 3:
+            s = -s
+        # Step 7
+        n1 = n % a1
+        # Step 8
+        return s * IntegerNative.jacobi_symbol(n1, a1)
+
+    @staticmethod
+    def _mult_modulo_bytes(term1, term2, modulus):
+        if modulus < 0:
+            raise ValueError("Modulus must be positive")
+        if modulus == 0:
+            raise ZeroDivisionError("Modulus cannot be zero")
+        if (modulus & 1) == 0:
+            raise ValueError("Odd modulus is required")
+
+        number_len = len(long_to_bytes(modulus))
+        return long_to_bytes((term1 * term2) % modulus, number_len)

wemm/lib/python3.10/site-packages/Crypto/Math/_IntegerNative.pyi

@@ -0,0 +1,3 @@
+from ._IntegerBase import IntegerBase
+class IntegerNative(IntegerBase):
+    pass

wemm/lib/python3.10/site-packages/Crypto/SelfTest/Cipher/common.py

@@ -0,0 +1,510 @@
+# -*- coding: utf-8 -*-
+#
+#  SelfTest/Hash/common.py: Common code for Crypto.SelfTest.Hash
+#
+# 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-testing for PyCrypto hash modules"""
+
+import unittest
+from binascii import a2b_hex, b2a_hex, hexlify
+
+from Crypto.Util.py3compat import b
+from Crypto.Util.strxor import strxor_c
+
+class _NoDefault: pass        # sentinel object
+def _extract(d, k, default=_NoDefault):
+    """Get an item from a dictionary, and remove it from the dictionary."""
+    try:
+        retval = d[k]
+    except KeyError:
+        if default is _NoDefault:
+            raise
+        return default
+    del d[k]
+    return retval
+
+# Generic cipher test case
+class CipherSelfTest(unittest.TestCase):
+
+    def __init__(self, module, params):
+        unittest.TestCase.__init__(self)
+        self.module = module
+
+        # Extract the parameters
+        params = params.copy()
+        self.description = _extract(params, 'description')
+        self.key = b(_extract(params, 'key'))
+        self.plaintext = b(_extract(params, 'plaintext'))
+        self.ciphertext = b(_extract(params, 'ciphertext'))
+        self.module_name = _extract(params, 'module_name', None)
+        self.assoc_data = _extract(params, 'assoc_data', None)
+        self.mac = _extract(params, 'mac', None)
+        if self.assoc_data:
+            self.mac = b(self.mac)
+
+        mode = _extract(params, 'mode', None)
+        self.mode_name = str(mode)
+
+        if mode is not None:
+            # Block cipher
+            self.mode = getattr(self.module, "MODE_" + mode)
+
+            self.iv = _extract(params, 'iv', None)
+            if self.iv is None:
+                self.iv = _extract(params, 'nonce', None)
+            if self.iv is not None:
+                self.iv = b(self.iv)
+
+        else:
+            # Stream cipher
+            self.mode = None
+            self.iv = _extract(params, 'iv', None)
+            if self.iv is not None:
+                self.iv = b(self.iv)
+
+        self.extra_params = params
+
+    def shortDescription(self):
+        return self.description
+
+    def _new(self):
+        params = self.extra_params.copy()
+        key = a2b_hex(self.key)
+
+        old_style = []
+        if self.mode is not None:
+            old_style = [ self.mode ]
+        if self.iv is not None:
+            old_style += [ a2b_hex(self.iv) ]
+
+        return self.module.new(key, *old_style, **params)
+
+    def isMode(self, name):
+        if not hasattr(self.module, "MODE_"+name):
+            return False
+        return self.mode == getattr(self.module, "MODE_"+name)
+
+    def runTest(self):
+        plaintext = a2b_hex(self.plaintext)
+        ciphertext = a2b_hex(self.ciphertext)
+        assoc_data = []
+        if self.assoc_data:
+            assoc_data = [ a2b_hex(b(x)) for x in self.assoc_data]
+
+        ct = None
+        pt = None
+
+        #
+        # Repeat the same encryption or decryption twice and verify
+        # that the result is always the same
+        #
+        for i in range(2):
+            cipher = self._new()
+            decipher = self._new()
+
+            # Only AEAD modes
+            for comp in assoc_data:
+                cipher.update(comp)
+                decipher.update(comp)
+
+            ctX = b2a_hex(cipher.encrypt(plaintext))
+            ptX = b2a_hex(decipher.decrypt(ciphertext))
+
+            if ct:
+                self.assertEqual(ct, ctX)
+                self.assertEqual(pt, ptX)
+            ct, pt = ctX, ptX
+
+        self.assertEqual(self.ciphertext, ct)  # encrypt
+        self.assertEqual(self.plaintext, pt)   # decrypt
+
+        if self.mac:
+            mac = b2a_hex(cipher.digest())
+            self.assertEqual(self.mac, mac)
+            decipher.verify(a2b_hex(self.mac))
+
+class CipherStreamingSelfTest(CipherSelfTest):
+
+    def shortDescription(self):
+        desc = self.module_name
+        if self.mode is not None:
+            desc += " in %s mode" % (self.mode_name,)
+        return "%s should behave like a stream cipher" % (desc,)
+
+    def runTest(self):
+        plaintext = a2b_hex(self.plaintext)
+        ciphertext = a2b_hex(self.ciphertext)
+
+        # The cipher should work like a stream cipher
+
+        # Test counter mode encryption, 3 bytes at a time
+        ct3 = []
+        cipher = self._new()
+        for i in range(0, len(plaintext), 3):
+            ct3.append(cipher.encrypt(plaintext[i:i+3]))
+        ct3 = b2a_hex(b("").join(ct3))
+        self.assertEqual(self.ciphertext, ct3)  # encryption (3 bytes at a time)
+
+        # Test counter mode decryption, 3 bytes at a time
+        pt3 = []
+        cipher = self._new()
+        for i in range(0, len(ciphertext), 3):
+            pt3.append(cipher.encrypt(ciphertext[i:i+3]))
+        # PY3K: This is meant to be text, do not change to bytes (data)
+        pt3 = b2a_hex(b("").join(pt3))
+        self.assertEqual(self.plaintext, pt3)  # decryption (3 bytes at a time)
+
+
+class RoundtripTest(unittest.TestCase):
+    def __init__(self, module, params):
+        from Crypto import Random
+        unittest.TestCase.__init__(self)
+        self.module = module
+        self.iv = Random.get_random_bytes(module.block_size)
+        self.key = b(params['key'])
+        self.plaintext = 100 * b(params['plaintext'])
+        self.module_name = params.get('module_name', None)
+
+    def shortDescription(self):
+        return """%s .decrypt() output of .encrypt() should not be garbled""" % (self.module_name,)
+
+    def runTest(self):
+
+        ## ECB mode
+        mode = self.module.MODE_ECB
+        encryption_cipher = self.module.new(a2b_hex(self.key), mode)
+        ciphertext = encryption_cipher.encrypt(self.plaintext)
+        decryption_cipher = self.module.new(a2b_hex(self.key), mode)
+        decrypted_plaintext = decryption_cipher.decrypt(ciphertext)
+        self.assertEqual(self.plaintext, decrypted_plaintext)
+
+
+class IVLengthTest(unittest.TestCase):
+    def __init__(self, module, params):
+        unittest.TestCase.__init__(self)
+        self.module = module
+        self.key = b(params['key'])
+
+    def shortDescription(self):
+        return "Check that all modes except MODE_ECB and MODE_CTR require an IV of the proper length"
+
+    def runTest(self):
+        self.assertRaises(TypeError, self.module.new, a2b_hex(self.key),
+                self.module.MODE_ECB, b(""))
+
+    def _dummy_counter(self):
+        return "\0" * self.module.block_size
+
+
+class NoDefaultECBTest(unittest.TestCase):
+    def __init__(self, module, params):
+        unittest.TestCase.__init__(self)
+        self.module = module
+        self.key = b(params['key'])
+
+    def runTest(self):
+        self.assertRaises(TypeError, self.module.new, a2b_hex(self.key))
+
+
+class BlockSizeTest(unittest.TestCase):
+    def __init__(self, module, params):
+        unittest.TestCase.__init__(self)
+        self.module = module
+        self.key = a2b_hex(b(params['key']))
+
+    def runTest(self):
+        cipher = self.module.new(self.key, self.module.MODE_ECB)
+        self.assertEqual(cipher.block_size, self.module.block_size)
+
+
+class ByteArrayTest(unittest.TestCase):
+    """Verify we can use bytearray's for encrypting and decrypting"""
+
+    def __init__(self, module, params):
+        unittest.TestCase.__init__(self)
+        self.module = module
+
+        # Extract the parameters
+        params = params.copy()
+        self.description = _extract(params, 'description')
+        self.key = b(_extract(params, 'key'))
+        self.plaintext = b(_extract(params, 'plaintext'))
+        self.ciphertext = b(_extract(params, 'ciphertext'))
+        self.module_name = _extract(params, 'module_name', None)
+        self.assoc_data = _extract(params, 'assoc_data', None)
+        self.mac = _extract(params, 'mac', None)
+        if self.assoc_data:
+            self.mac = b(self.mac)
+
+        mode = _extract(params, 'mode', None)
+        self.mode_name = str(mode)
+
+        if mode is not None:
+            # Block cipher
+            self.mode = getattr(self.module, "MODE_" + mode)
+
+            self.iv = _extract(params, 'iv', None)
+            if self.iv is None:
+                self.iv = _extract(params, 'nonce', None)
+            if self.iv is not None:
+                self.iv = b(self.iv)
+        else:
+            # Stream cipher
+            self.mode = None
+            self.iv = _extract(params, 'iv', None)
+            if self.iv is not None:
+                self.iv = b(self.iv)
+
+        self.extra_params = params
+
+    def _new(self):
+        params = self.extra_params.copy()
+        key = a2b_hex(self.key)
+
+        old_style = []
+        if self.mode is not None:
+            old_style = [ self.mode ]
+        if self.iv is not None:
+            old_style += [ a2b_hex(self.iv) ]
+
+        return self.module.new(key, *old_style, **params)
+
+    def runTest(self):
+
+        plaintext = a2b_hex(self.plaintext)
+        ciphertext = a2b_hex(self.ciphertext)
+        assoc_data = []
+        if self.assoc_data:
+            assoc_data = [ bytearray(a2b_hex(b(x))) for x in self.assoc_data]
+
+        cipher = self._new()
+        decipher = self._new()
+
+        # Only AEAD modes
+        for comp in assoc_data:
+            cipher.update(comp)
+            decipher.update(comp)
+
+        ct = b2a_hex(cipher.encrypt(bytearray(plaintext)))
+        pt = b2a_hex(decipher.decrypt(bytearray(ciphertext)))
+
+        self.assertEqual(self.ciphertext, ct)  # encrypt
+        self.assertEqual(self.plaintext, pt)   # decrypt
+
+        if self.mac:
+            mac = b2a_hex(cipher.digest())
+            self.assertEqual(self.mac, mac)
+            decipher.verify(bytearray(a2b_hex(self.mac)))
+
+
+class MemoryviewTest(unittest.TestCase):
+    """Verify we can use memoryviews for encrypting and decrypting"""
+
+    def __init__(self, module, params):
+        unittest.TestCase.__init__(self)
+        self.module = module
+
+        # Extract the parameters
+        params = params.copy()
+        self.description = _extract(params, 'description')
+        self.key = b(_extract(params, 'key'))
+        self.plaintext = b(_extract(params, 'plaintext'))
+        self.ciphertext = b(_extract(params, 'ciphertext'))
+        self.module_name = _extract(params, 'module_name', None)
+        self.assoc_data = _extract(params, 'assoc_data', None)
+        self.mac = _extract(params, 'mac', None)
+        if self.assoc_data:
+            self.mac = b(self.mac)
+
+        mode = _extract(params, 'mode', None)
+        self.mode_name = str(mode)
+
+        if mode is not None:
+            # Block cipher
+            self.mode = getattr(self.module, "MODE_" + mode)
+
+            self.iv = _extract(params, 'iv', None)
+            if self.iv is None:
+                self.iv = _extract(params, 'nonce', None)
+            if self.iv is not None:
+                self.iv = b(self.iv)
+        else:
+            # Stream cipher
+            self.mode = None
+            self.iv = _extract(params, 'iv', None)
+            if self.iv is not None:
+                self.iv = b(self.iv)
+
+        self.extra_params = params
+
+    def _new(self):
+        params = self.extra_params.copy()
+        key = a2b_hex(self.key)
+
+        old_style = []
+        if self.mode is not None:
+            old_style = [ self.mode ]
+        if self.iv is not None:
+            old_style += [ a2b_hex(self.iv) ]
+
+        return self.module.new(key, *old_style, **params)
+
+    def runTest(self):
+
+        plaintext = a2b_hex(self.plaintext)
+        ciphertext = a2b_hex(self.ciphertext)
+        assoc_data = []
+        if self.assoc_data:
+            assoc_data = [ memoryview(a2b_hex(b(x))) for x in self.assoc_data]
+
+        cipher = self._new()
+        decipher = self._new()
+
+        # Only AEAD modes
+        for comp in assoc_data:
+            cipher.update(comp)
+            decipher.update(comp)
+
+        ct = b2a_hex(cipher.encrypt(memoryview(plaintext)))
+        pt = b2a_hex(decipher.decrypt(memoryview(ciphertext)))
+
+        self.assertEqual(self.ciphertext, ct)  # encrypt
+        self.assertEqual(self.plaintext, pt)   # decrypt
+
+        if self.mac:
+            mac = b2a_hex(cipher.digest())
+            self.assertEqual(self.mac, mac)
+            decipher.verify(memoryview(a2b_hex(self.mac)))
+
+
+def make_block_tests(module, module_name, test_data, additional_params=dict()):
+    tests = []
+    extra_tests_added = False
+    for i in range(len(test_data)):
+        row = test_data[i]
+
+        # Build the "params" dictionary with
+        # - plaintext
+        # - ciphertext
+        # - key
+        # - mode (default is ECB)
+        # - (optionally) description
+        # - (optionally) any other parameter that this cipher mode requires
+        params = {}
+        if len(row) == 3:
+            (params['plaintext'], params['ciphertext'], params['key']) = row
+        elif len(row) == 4:
+            (params['plaintext'], params['ciphertext'], params['key'], params['description']) = row
+        elif len(row) == 5:
+            (params['plaintext'], params['ciphertext'], params['key'], params['description'], extra_params) = row
+            params.update(extra_params)
+        else:
+            raise AssertionError("Unsupported tuple size %d" % (len(row),))
+
+        if not "mode" in params:
+            params["mode"] = "ECB"
+
+        # Build the display-name for the test
+        p2 = params.copy()
+        p_key = _extract(p2, 'key')
+        p_plaintext = _extract(p2, 'plaintext')
+        p_ciphertext = _extract(p2, 'ciphertext')
+        p_mode = _extract(p2, 'mode')
+        p_description = _extract(p2, 'description', None)
+
+        if p_description is not None:
+            description = p_description
+        elif p_mode == 'ECB' and not p2:
+            description = "p=%s, k=%s" % (p_plaintext, p_key)
+        else:
+            description = "p=%s, k=%s, %r" % (p_plaintext, p_key, p2)
+        name = "%s #%d: %s" % (module_name, i+1, description)
+        params['description'] = name
+        params['module_name'] = module_name
+        params.update(additional_params)
+
+        # Add extra test(s) to the test suite before the current test
+        if not extra_tests_added:
+            tests += [
+                RoundtripTest(module, params),
+                IVLengthTest(module, params),
+                NoDefaultECBTest(module, params),
+                ByteArrayTest(module, params),
+                BlockSizeTest(module, params),
+            ]
+            extra_tests_added = True
+
+        # Add the current test to the test suite
+        tests.append(CipherSelfTest(module, params))
+
+    return tests
+
+def make_stream_tests(module, module_name, test_data):
+    tests = []
+    extra_tests_added = False
+    for i in range(len(test_data)):
+        row = test_data[i]
+
+        # Build the "params" dictionary
+        params = {}
+        if len(row) == 3:
+            (params['plaintext'], params['ciphertext'], params['key']) = row
+        elif len(row) == 4:
+            (params['plaintext'], params['ciphertext'], params['key'], params['description']) = row
+        elif len(row) == 5:
+            (params['plaintext'], params['ciphertext'], params['key'], params['description'], extra_params) = row
+            params.update(extra_params)
+        else:
+            raise AssertionError("Unsupported tuple size %d" % (len(row),))
+
+        # Build the display-name for the test
+        p2 = params.copy()
+        p_key = _extract(p2, 'key')
+        p_plaintext = _extract(p2, 'plaintext')
+        p_ciphertext = _extract(p2, 'ciphertext')
+        p_description = _extract(p2, 'description', None)
+
+        if p_description is not None:
+            description = p_description
+        elif not p2:
+            description = "p=%s, k=%s" % (p_plaintext, p_key)
+        else:
+            description = "p=%s, k=%s, %r" % (p_plaintext, p_key, p2)
+        name = "%s #%d: %s" % (module_name, i+1, description)
+        params['description'] = name
+        params['module_name'] = module_name
+
+        # Add extra test(s) to the test suite before the current test
+        if not extra_tests_added:
+            tests += [
+                ByteArrayTest(module, params),
+            ]
+
+            tests.append(MemoryviewTest(module, params))
+            extra_tests_added = True
+
+        # Add the test to the test suite
+        tests.append(CipherSelfTest(module, params))
+        tests.append(CipherStreamingSelfTest(module, params))
+    return tests
+
+# vim:set ts=4 sw=4 sts=4 expandtab:

wemm/lib/python3.10/site-packages/Crypto/SelfTest/Cipher/test_ChaCha20.py

@@ -0,0 +1,529 @@
+# ===================================================================
+#
+# 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 os
+import re
+import unittest
+from binascii import hexlify, unhexlify
+
+from Crypto.Util.py3compat import b, tobytes, bchr
+from Crypto.Util.strxor import strxor_c
+from Crypto.SelfTest.st_common import list_test_cases
+
+from Crypto.Cipher import ChaCha20
+
+
+class ChaCha20Test(unittest.TestCase):
+
+    def test_new_positive(self):
+        cipher = ChaCha20.new(key=b("0")*32, nonce=b"0"*8)
+        self.assertEqual(cipher.nonce, b"0" * 8)
+        cipher = ChaCha20.new(key=b("0")*32, nonce=b"0"*12)
+        self.assertEqual(cipher.nonce, b"0" * 12)
+
+    def test_new_negative(self):
+        new = ChaCha20.new
+        self.assertRaises(TypeError, new)
+        self.assertRaises(TypeError, new, nonce=b("0"))
+        self.assertRaises(ValueError, new, nonce=b("0")*8, key=b("0"))
+        self.assertRaises(ValueError, new, nonce=b("0"), key=b("0")*32)
+
+    def test_default_nonce(self):
+        cipher1 = ChaCha20.new(key=bchr(1) * 32)
+        cipher2 = ChaCha20.new(key=bchr(1) * 32)
+        self.assertEqual(len(cipher1.nonce), 8)
+        self.assertNotEqual(cipher1.nonce, cipher2.nonce)
+
+    def test_nonce(self):
+        key = b'A' * 32
+
+        nonce1 = b'P' * 8
+        cipher1 = ChaCha20.new(key=key, nonce=nonce1)
+        self.assertEqual(nonce1, cipher1.nonce)
+
+        nonce2 = b'Q' * 12
+        cipher2 = ChaCha20.new(key=key, nonce=nonce2)
+        self.assertEqual(nonce2, cipher2.nonce)
+
+    def test_eiter_encrypt_or_decrypt(self):
+        """Verify that a cipher cannot be used for both decrypting and encrypting"""
+
+        c1 = ChaCha20.new(key=b("5") * 32, nonce=b("6") * 8)
+        c1.encrypt(b("8"))
+        self.assertRaises(TypeError, c1.decrypt, b("9"))
+
+        c2 = ChaCha20.new(key=b("5") * 32, nonce=b("6") * 8)
+        c2.decrypt(b("8"))
+        self.assertRaises(TypeError, c2.encrypt, b("9"))
+
+    def test_round_trip(self):
+        pt = b("A") * 1024
+        c1 = ChaCha20.new(key=b("5") * 32, nonce=b("6") * 8)
+        c2 = ChaCha20.new(key=b("5") * 32, nonce=b("6") * 8)
+        ct = c1.encrypt(pt)
+        self.assertEqual(c2.decrypt(ct), pt)
+
+        self.assertEqual(c1.encrypt(b("")), b(""))
+        self.assertEqual(c2.decrypt(b("")), b(""))
+
+    def test_streaming(self):
+        """Verify that an arbitrary number of bytes can be encrypted/decrypted"""
+        from Crypto.Hash import SHA1
+
+        segments = (1, 3, 5, 7, 11, 17, 23)
+        total = sum(segments)
+
+        pt = b("")
+        while len(pt) < total:
+            pt += SHA1.new(pt).digest()
+
+        cipher1 = ChaCha20.new(key=b("7") * 32, nonce=b("t") * 8)
+        ct = cipher1.encrypt(pt)
+
+        cipher2 = ChaCha20.new(key=b("7") * 32, nonce=b("t") * 8)
+        cipher3 = ChaCha20.new(key=b("7") * 32, nonce=b("t") * 8)
+        idx = 0
+        for segment in segments:
+            self.assertEqual(cipher2.decrypt(ct[idx:idx+segment]), pt[idx:idx+segment])
+            self.assertEqual(cipher3.encrypt(pt[idx:idx+segment]), ct[idx:idx+segment])
+            idx += segment
+
+    def test_seek(self):
+        cipher1 = ChaCha20.new(key=b("9") * 32, nonce=b("e") * 8)
+
+        offset = 64 * 900 + 7
+        pt = b("1") * 64
+
+        cipher1.encrypt(b("0") * offset)
+        ct1 = cipher1.encrypt(pt)
+
+        cipher2 = ChaCha20.new(key=b("9") * 32, nonce=b("e") * 8)
+        cipher2.seek(offset)
+        ct2 = cipher2.encrypt(pt)
+
+        self.assertEqual(ct1, ct2)
+
+    def test_seek_tv(self):
+        # Test Vector #4, A.1 from
+        # http://tools.ietf.org/html/draft-nir-cfrg-chacha20-poly1305-04
+        key = bchr(0) + bchr(255) + bchr(0) * 30
+        nonce = bchr(0) * 8
+        cipher = ChaCha20.new(key=key, nonce=nonce)
+        cipher.seek(64 * 2)
+        expected_key_stream = unhexlify(b(
+            "72d54dfbf12ec44b362692df94137f32"
+            "8fea8da73990265ec1bbbea1ae9af0ca"
+            "13b25aa26cb4a648cb9b9d1be65b2c09"
+            "24a66c54d545ec1b7374f4872e99f096"
+            ))
+        ct = cipher.encrypt(bchr(0) * len(expected_key_stream))
+        self.assertEqual(expected_key_stream, ct)
+
+    def test_rfc7539(self):
+        # from https://tools.ietf.org/html/rfc7539 Annex A.1
+        # Each item is: key, nonce, block #, plaintext, ciphertext
+        tvs = [
+                # Test Vector #1
+                (
+                    "00"*32,
+                    "00"*12,
+                    0,
+                    "00"*16*4,
+                    "76b8e0ada0f13d90405d6ae55386bd28"
+                    "bdd219b8a08ded1aa836efcc8b770dc7"
+                    "da41597c5157488d7724e03fb8d84a37"
+                    "6a43b8f41518a11cc387b669b2ee6586"
+                ),
+                # Test Vector #2
+                (
+                    "00"*31 + "01",
+                    "00"*11 + "02",
+                    1,
+                    "416e79207375626d697373696f6e2074"
+                    "6f20746865204945544620696e74656e"
+                    "6465642062792074686520436f6e7472"
+                    "696275746f7220666f72207075626c69"
+                    "636174696f6e20617320616c6c206f72"
+                    "2070617274206f6620616e2049455446"
+                    "20496e7465726e65742d447261667420"
+                    "6f722052464320616e6420616e792073"
+                    "746174656d656e74206d616465207769"
+                    "7468696e2074686520636f6e74657874"
+                    "206f6620616e20494554462061637469"
+                    "7669747920697320636f6e7369646572"
+                    "656420616e20224945544620436f6e74"
+                    "7269627574696f6e222e205375636820"
+                    "73746174656d656e747320696e636c75"
+                    "6465206f72616c2073746174656d656e"
+                    "747320696e2049455446207365737369"
+                    "6f6e732c2061732077656c6c20617320"
+                    "7772697474656e20616e6420656c6563"
+                    "74726f6e696320636f6d6d756e696361"
+                    "74696f6e73206d61646520617420616e"
+                    "792074696d65206f7220706c6163652c"
+                    "20776869636820617265206164647265"
+                    "7373656420746f",
+                    "a3fbf07df3fa2fde4f376ca23e827370"
+                    "41605d9f4f4f57bd8cff2c1d4b7955ec"
+                    "2a97948bd3722915c8f3d337f7d37005"
+                    "0e9e96d647b7c39f56e031ca5eb6250d"
+                    "4042e02785ececfa4b4bb5e8ead0440e"
+                    "20b6e8db09d881a7c6132f420e527950"
+                    "42bdfa7773d8a9051447b3291ce1411c"
+                    "680465552aa6c405b7764d5e87bea85a"
+                    "d00f8449ed8f72d0d662ab052691ca66"
+                    "424bc86d2df80ea41f43abf937d3259d"
+                    "c4b2d0dfb48a6c9139ddd7f76966e928"
+                    "e635553ba76c5c879d7b35d49eb2e62b"
+                    "0871cdac638939e25e8a1e0ef9d5280f"
+                    "a8ca328b351c3c765989cbcf3daa8b6c"
+                    "cc3aaf9f3979c92b3720fc88dc95ed84"
+                    "a1be059c6499b9fda236e7e818b04b0b"
+                    "c39c1e876b193bfe5569753f88128cc0"
+                    "8aaa9b63d1a16f80ef2554d7189c411f"
+                    "5869ca52c5b83fa36ff216b9c1d30062"
+                    "bebcfd2dc5bce0911934fda79a86f6e6"
+                    "98ced759c3ff9b6477338f3da4f9cd85"
+                    "14ea9982ccafb341b2384dd902f3d1ab"
+                    "7ac61dd29c6f21ba5b862f3730e37cfd"
+                    "c4fd806c22f221"
+                ),
+                # Test Vector #3
+                (
+                    "1c9240a5eb55d38af333888604f6b5f0"
+                    "473917c1402b80099dca5cbc207075c0",
+                    "00"*11 + "02",
+                    42,
+                    "2754776173206272696c6c69672c2061"
+                    "6e642074686520736c6974687920746f"
+                    "7665730a446964206779726520616e64"
+                    "2067696d626c6520696e207468652077"
+                    "6162653a0a416c6c206d696d73792077"
+                    "6572652074686520626f726f676f7665"
+                    "732c0a416e6420746865206d6f6d6520"
+                    "7261746873206f757467726162652e",
+                    "62e6347f95ed87a45ffae7426f27a1df"
+                    "5fb69110044c0d73118effa95b01e5cf"
+                    "166d3df2d721caf9b21e5fb14c616871"
+                    "fd84c54f9d65b283196c7fe4f60553eb"
+                    "f39c6402c42234e32a356b3e764312a6"
+                    "1a5532055716ead6962568f87d3f3f77"
+                    "04c6a8d1bcd1bf4d50d6154b6da731b1"
+                    "87b58dfd728afa36757a797ac188d1"
+                )
+        ]
+
+        for tv in tvs:
+            key = unhexlify(tv[0])
+            nonce = unhexlify(tv[1])
+            offset = tv[2] * 64
+            pt = unhexlify(tv[3])
+            ct_expect = unhexlify(tv[4])
+
+            cipher = ChaCha20.new(key=key, nonce=nonce)
+            if offset != 0:
+                cipher.seek(offset)
+            ct = cipher.encrypt(pt)
+            assert(ct == ct_expect)
+
+
+class XChaCha20Test(unittest.TestCase):
+
+    # From https://tools.ietf.org/html/draft-arciszewski-xchacha-03
+
+    def test_hchacha20(self):
+        # Section 2.2.1
+
+        from Crypto.Cipher.ChaCha20 import _HChaCha20
+
+        key = b"00:01:02:03:04:05:06:07:08:09:0a:0b:0c:0d:0e:0f:10:11:12:13:14:15:16:17:18:19:1a:1b:1c:1d:1e:1f"
+        key = unhexlify(key.replace(b":", b""))
+
+        nonce = b"00:00:00:09:00:00:00:4a:00:00:00:00:31:41:59:27"
+        nonce = unhexlify(nonce.replace(b":", b""))
+
+        subkey = _HChaCha20(key, nonce)
+
+        expected = b"82413b42 27b27bfe d30e4250 8a877d73 a0f9e4d5 8a74a853 c12ec413 26d3ecdc"
+        expected = unhexlify(expected.replace(b" ", b""))
+
+        self.assertEqual(subkey, expected)
+
+    def test_nonce(self):
+        key = b'A' * 32
+        nonce = b'P' * 24
+        cipher = ChaCha20.new(key=key, nonce=nonce)
+        self.assertEqual(nonce, cipher.nonce)
+
+    def test_encrypt(self):
+        # Section A.3.2
+
+        pt = b"""
+                5468652064686f6c65202870726f6e6f756e6365642022646f6c652229206973
+                20616c736f206b6e6f776e2061732074686520417369617469632077696c6420
+                646f672c2072656420646f672c20616e642077686973746c696e6720646f672e
+                2049742069732061626f7574207468652073697a65206f662061204765726d61
+                6e20736865706865726420627574206c6f6f6b73206d6f7265206c696b652061
+                206c6f6e672d6c656767656420666f782e205468697320686967686c7920656c
+                757369766520616e6420736b696c6c6564206a756d70657220697320636c6173
+                736966696564207769746820776f6c7665732c20636f796f7465732c206a6163
+                6b616c732c20616e6420666f78657320696e20746865207461786f6e6f6d6963
+                2066616d696c792043616e696461652e"""
+        pt = unhexlify(pt.replace(b"\n", b"").replace(b" ", b""))
+
+        key = unhexlify(b"808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9f")
+        iv = unhexlify(b"404142434445464748494a4b4c4d4e4f5051525354555658")
+
+        ct = b"""
+                7d0a2e6b7f7c65a236542630294e063b7ab9b555a5d5149aa21e4ae1e4fbce87
+                ecc8e08a8b5e350abe622b2ffa617b202cfad72032a3037e76ffdcdc4376ee05
+                3a190d7e46ca1de04144850381b9cb29f051915386b8a710b8ac4d027b8b050f
+                7cba5854e028d564e453b8a968824173fc16488b8970cac828f11ae53cabd201
+                12f87107df24ee6183d2274fe4c8b1485534ef2c5fbc1ec24bfc3663efaa08bc
+                047d29d25043532db8391a8a3d776bf4372a6955827ccb0cdd4af403a7ce4c63
+                d595c75a43e045f0cce1f29c8b93bd65afc5974922f214a40b7c402cdb91ae73
+                c0b63615cdad0480680f16515a7ace9d39236464328a37743ffc28f4ddb324f4
+                d0f5bbdc270c65b1749a6efff1fbaa09536175ccd29fb9e6057b307320d31683
+                8a9c71f70b5b5907a66f7ea49aadc409"""
+        ct = unhexlify(ct.replace(b"\n", b"").replace(b" ", b""))
+
+        cipher = ChaCha20.new(key=key, nonce=iv)
+        cipher.seek(64) # Counter = 1
+        ct_test = cipher.encrypt(pt)
+        self.assertEqual(ct, ct_test)
+
+
+class ByteArrayTest(unittest.TestCase):
+    """Verify we can encrypt or decrypt bytearrays"""
+
+    def runTest(self):
+
+        data = b"0123"
+        key = b"9" * 32
+        nonce = b"t" * 8
+
+        # Encryption
+        data_ba = bytearray(data)
+        key_ba = bytearray(key)
+        nonce_ba = bytearray(nonce)
+
+        cipher1 = ChaCha20.new(key=key, nonce=nonce)
+        ct = cipher1.encrypt(data)
+
+        cipher2 = ChaCha20.new(key=key_ba, nonce=nonce_ba)
+        key_ba[:1] = b'\xFF'
+        nonce_ba[:1] = b'\xFF'
+        ct_test = cipher2.encrypt(data_ba)
+
+        self.assertEqual(ct, ct_test)
+        self.assertEqual(cipher1.nonce, cipher2.nonce)
+
+        # Decryption
+        key_ba = bytearray(key)
+        nonce_ba = bytearray(nonce)
+        ct_ba = bytearray(ct)
+
+        cipher3 = ChaCha20.new(key=key_ba, nonce=nonce_ba)
+        key_ba[:1] = b'\xFF'
+        nonce_ba[:1] = b'\xFF'
+        pt_test = cipher3.decrypt(ct_ba)
+
+        self.assertEqual(data, pt_test)
+
+
+class MemoryviewTest(unittest.TestCase):
+    """Verify we can encrypt or decrypt bytearrays"""
+
+    def runTest(self):
+
+        data = b"0123"
+        key = b"9" * 32
+        nonce = b"t" * 8
+
+        # Encryption
+        data_mv = memoryview(bytearray(data))
+        key_mv = memoryview(bytearray(key))
+        nonce_mv = memoryview(bytearray(nonce))
+
+        cipher1 = ChaCha20.new(key=key, nonce=nonce)
+        ct = cipher1.encrypt(data)
+
+        cipher2 = ChaCha20.new(key=key_mv, nonce=nonce_mv)
+        key_mv[:1] = b'\xFF'
+        nonce_mv[:1] = b'\xFF'
+        ct_test = cipher2.encrypt(data_mv)
+
+        self.assertEqual(ct, ct_test)
+        self.assertEqual(cipher1.nonce, cipher2.nonce)
+
+        # Decryption
+        key_mv = memoryview(bytearray(key))
+        nonce_mv = memoryview(bytearray(nonce))
+        ct_mv = memoryview(bytearray(ct))
+
+        cipher3 = ChaCha20.new(key=key_mv, nonce=nonce_mv)
+        key_mv[:1] = b'\xFF'
+        nonce_mv[:1] = b'\xFF'
+        pt_test = cipher3.decrypt(ct_mv)
+
+        self.assertEqual(data, pt_test)
+
+
+class ChaCha20_AGL_NIR(unittest.TestCase):
+
+    # From http://tools.ietf.org/html/draft-agl-tls-chacha20poly1305-04
+    # and http://tools.ietf.org/html/draft-nir-cfrg-chacha20-poly1305-04
+    tv = [
+          ( "00" * 32,
+            "00" * 8,
+            "76b8e0ada0f13d90405d6ae55386bd28bdd219b8a08ded1aa836efcc"
+            "8b770dc7da41597c5157488d7724e03fb8d84a376a43b8f41518a11c"
+            "c387b669b2ee6586"
+            "9f07e7be5551387a98ba977c732d080d"
+            "cb0f29a048e3656912c6533e32ee7aed"
+            "29b721769ce64e43d57133b074d839d5"
+            "31ed1f28510afb45ace10a1f4b794d6f"
+          ),
+          ( "00" * 31 + "01",
+            "00" * 8,
+            "4540f05a9f1fb296d7736e7b208e3c96eb4fe1834688d2604f450952"
+            "ed432d41bbe2a0b6ea7566d2a5d1e7e20d42af2c53d792b1c43fea81"
+            "7e9ad275ae546963"
+            "3aeb5224ecf849929b9d828db1ced4dd"
+            "832025e8018b8160b82284f3c949aa5a"
+            "8eca00bbb4a73bdad192b5c42f73f2fd"
+            "4e273644c8b36125a64addeb006c13a0"
+          ),
+          ( "00" * 32,
+            "00" * 7 + "01",
+            "de9cba7bf3d69ef5e786dc63973f653a0b49e015adbff7134fcb7df1"
+            "37821031e85a050278a7084527214f73efc7fa5b5277062eb7a0433e"
+            "445f41e3"
+          ),
+          ( "00" * 32,
+            "01" + "00" * 7,
+            "ef3fdfd6c61578fbf5cf35bd3dd33b8009631634d21e42ac33960bd1"
+            "38e50d32111e4caf237ee53ca8ad6426194a88545ddc497a0b466e7d"
+            "6bbdb0041b2f586b"
+          ),
+          ( "000102030405060708090a0b0c0d0e0f101112131415161718191a1b"
+            "1c1d1e1f",
+            "0001020304050607",
+            "f798a189f195e66982105ffb640bb7757f579da31602fc93ec01ac56"
+            "f85ac3c134a4547b733b46413042c9440049176905d3be59ea1c53f1"
+            "5916155c2be8241a38008b9a26bc35941e2444177c8ade6689de9526"
+            "4986d95889fb60e84629c9bd9a5acb1cc118be563eb9b3a4a472f82e"
+            "09a7e778492b562ef7130e88dfe031c79db9d4f7c7a899151b9a4750"
+            "32b63fc385245fe054e3dd5a97a5f576fe064025d3ce042c566ab2c5"
+            "07b138db853e3d6959660996546cc9c4a6eafdc777c040d70eaf46f7"
+            "6dad3979e5c5360c3317166a1c894c94a371876a94df7628fe4eaaf2"
+            "ccb27d5aaae0ad7ad0f9d4b6ad3b54098746d4524d38407a6deb3ab7"
+            "8fab78c9"
+          ),
+          ( "00" * 32,
+            "00" * 7 + "02",
+            "c2c64d378cd536374ae204b9ef933fcd"
+            "1a8b2288b3dfa49672ab765b54ee27c7"
+            "8a970e0e955c14f3a88e741b97c286f7"
+            "5f8fc299e8148362fa198a39531bed6d"
+          ),
+         ]
+
+    def runTest(self):
+        for (key, nonce, stream) in self.tv:
+            c = ChaCha20.new(key=unhexlify(b(key)), nonce=unhexlify(b(nonce)))
+            ct = unhexlify(b(stream))
+            pt = b("\x00") * len(ct)
+            self.assertEqual(c.encrypt(pt), ct)
+
+
+class TestOutput(unittest.TestCase):
+
+    def runTest(self):
+        # Encrypt/Decrypt data and test output parameter
+
+        key = b'4' * 32
+        nonce = b'5' * 8
+        cipher = ChaCha20.new(key=key, nonce=nonce)
+
+        pt = b'5' * 300
+        ct = cipher.encrypt(pt)
+
+        output = bytearray(len(pt))
+        cipher = ChaCha20.new(key=key, nonce=nonce)
+        res = cipher.encrypt(pt, output=output)
+        self.assertEqual(ct, output)
+        self.assertEqual(res, None)
+
+        cipher = ChaCha20.new(key=key, nonce=nonce)
+        res = cipher.decrypt(ct, output=output)
+        self.assertEqual(pt, output)
+        self.assertEqual(res, None)
+
+        output = memoryview(bytearray(len(pt)))
+        cipher = ChaCha20.new(key=key, nonce=nonce)
+        cipher.encrypt(pt, output=output)
+        self.assertEqual(ct, output)
+
+        cipher = ChaCha20.new(key=key, nonce=nonce)
+        cipher.decrypt(ct, output=output)
+        self.assertEqual(pt, output)
+
+        cipher = ChaCha20.new(key=key, nonce=nonce)
+        self.assertRaises(TypeError, cipher.encrypt, pt, output=b'0'*len(pt))
+
+        cipher = ChaCha20.new(key=key, nonce=nonce)
+        self.assertRaises(TypeError, cipher.decrypt, ct, output=b'0'*len(pt))
+
+        shorter_output = bytearray(len(pt) - 1)
+
+        cipher = ChaCha20.new(key=key, nonce=nonce)
+        self.assertRaises(ValueError, cipher.encrypt, pt, output=shorter_output)
+
+        cipher = ChaCha20.new(key=key, nonce=nonce)
+        self.assertRaises(ValueError, cipher.decrypt, ct, output=shorter_output)
+
+
+def get_tests(config={}):
+    tests = []
+    tests += list_test_cases(ChaCha20Test)
+    tests += list_test_cases(XChaCha20Test)
+    tests.append(ChaCha20_AGL_NIR())
+    tests.append(ByteArrayTest())
+    tests.append(MemoryviewTest())
+    tests.append(TestOutput())
+
+    return tests
+
+
+if __name__ == '__main__':
+    import unittest
+    suite = lambda: unittest.TestSuite(get_tests())
+    unittest.main(defaultTest='suite')

wemm/lib/python3.10/site-packages/Crypto/SelfTest/Cipher/test_pkcs1_15.py

@@ -0,0 +1,283 @@
+# -*- coding: utf-8 -*-
+#
+#  SelfTest/Cipher/test_pkcs1_15.py: Self-test for PKCS#1 v1.5 encryption
+#
+# ===================================================================
+# 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.
+# ===================================================================
+
+from __future__ import print_function
+
+import unittest
+
+from Crypto.PublicKey import RSA
+from Crypto.SelfTest.st_common import list_test_cases, a2b_hex
+from Crypto import Random
+from Crypto.Cipher import PKCS1_v1_5 as PKCS
+from Crypto.Util.py3compat import b
+from Crypto.Util.number import bytes_to_long, long_to_bytes
+from Crypto.SelfTest.loader import load_test_vectors_wycheproof
+
+
+def rws(t):
+    """Remove white spaces, tabs, and new lines from a string"""
+    for c in ['\n', '\t', ' ']:
+        t = t.replace(c, '')
+    return t
+
+
+def t2b(t):
+    """Convert a text string with bytes in hex form to a byte string"""
+    clean = b(rws(t))
+    if len(clean) % 2 == 1:
+        raise ValueError("Even number of characters expected")
+    return a2b_hex(clean)
+
+
+class PKCS1_15_Tests(unittest.TestCase):
+
+        def setUp(self):
+                self.rng = Random.new().read
+                self.key1024 = RSA.generate(1024, self.rng)
+
+        # List of tuples with test data for PKCS#1 v1.5.
+        # Each tuple is made up by:
+        #       Item #0: dictionary with RSA key component, or key to import
+        #       Item #1: plaintext
+        #       Item #2: ciphertext
+        #       Item #3: random data
+
+        _testData = (
+
+                #
+                # Generated with openssl 0.9.8o
+                #
+                (
+                # Private key
+                '''-----BEGIN RSA PRIVATE KEY-----
+MIICXAIBAAKBgQDAiAnvIAOvqVwJTaYzsKnefZftgtXGE2hPJppGsWl78yz9jeXY
+W/FxX/gTPURArNhdnhP6n3p2ZaDIBrO2zizbgIXs0IsljTTcr4vnI8fMXzyNUOjA
+zP3nzMqZDZK6757XQAobOssMkBFqRWwilT/3DsBhRpl3iMUhF+wvpTSHewIDAQAB
+AoGAC4HV/inOrpgTvSab8Wj0riyZgQOZ3U3ZpSlsfR8ra9Ib9Uee3jCYnKscu6Gk
+y6zI/cdt8EPJ4PuwAWSNJzbpbVaDvUq25OD+CX8/uRT08yBS4J8TzBitZJTD4lS7
+atdTnKT0Wmwk+u8tDbhvMKwnUHdJLcuIsycts9rwJVapUtkCQQDvDpx2JMun0YKG
+uUttjmL8oJ3U0m3ZvMdVwBecA0eebZb1l2J5PvI3EJD97eKe91Nsw8T3lwpoN40k
+IocSVDklAkEAzi1HLHE6EzVPOe5+Y0kGvrIYRRhncOb72vCvBZvD6wLZpQgqo6c4
+d3XHFBBQWA6xcvQb5w+VVEJZzw64y25sHwJBAMYReRl6SzL0qA0wIYrYWrOt8JeQ
+8mthulcWHXmqTgC6FEXP9Es5GD7/fuKl4wqLKZgIbH4nqvvGay7xXLCXD/ECQH9a
+1JYNMtRen5unSAbIOxRcKkWz92F0LKpm9ZW/S9vFHO+mBcClMGoKJHiuQxLBsLbT
+NtEZfSJZAeS2sUtn3/0CQDb2M2zNBTF8LlM0nxmh0k9VGm5TVIyBEMcipmvOgqIs
+HKukWBcq9f/UOmS0oEhai/6g+Uf7VHJdWaeO5LzuvwU=
+-----END RSA PRIVATE KEY-----''',
+                # Plaintext
+                '''THIS IS PLAINTEXT\x0A''',
+                # Ciphertext
+                '''3f dc fd 3c cd 5c 9b 12  af 65 32 e3 f7 d0 da 36
+                8f 8f d9 e3 13 1c 7f c8  b3 f9 c1 08 e4 eb 79 9c
+                91 89 1f 96 3b 94 77 61  99 a4 b1 ee 5d e6 17 c9
+                5d 0a b5 63 52 0a eb 00  45 38 2a fb b0 71 3d 11
+                f7 a1 9e a7 69 b3 af 61  c0 bb 04 5b 5d 4b 27 44
+                1f 5b 97 89 ba 6a 08 95  ee 4f a2 eb 56 64 e5 0f
+                da 7c f9 9a 61 61 06 62  ed a0 bc 5f aa 6c 31 78
+                70 28 1a bb 98 3c e3 6a  60 3c d1 0b 0f 5a f4 75''',
+                # Random data
+                '''eb d7 7d 86 a4 35 23 a3 54 7e 02 0b 42 1d
+                61 6c af 67 b8 4e 17 56 80 66 36 04 64 34 26 8a
+                47 dd 44 b3 1a b2 17 60 f4 91 2e e2 b5 95 64 cc
+                f9 da c8 70 94 54 86 4c ef 5b 08 7d 18 c4 ab 8d
+                04 06 33 8f ca 15 5f 52 60 8a a1 0c f5 08 b5 4c
+                bb 99 b8 94 25 04 9c e6 01 75 e6 f9 63 7a 65 61
+                13 8a a7 47 77 81 ae 0d b8 2c 4d 50 a5'''
+                ),
+        )
+
+        def testEncrypt1(self):
+                for test in self._testData:
+                        # Build the key
+                        key = RSA.importKey(test[0])
+                        # RNG that takes its random numbers from a pool given
+                        # at initialization
+                        class randGen:
+                            def __init__(self, data):
+                                self.data = data
+                                self.idx = 0
+                            def __call__(self, N):
+                                r = self.data[self.idx:self.idx+N]
+                                self.idx += N
+                                return r
+                        # The real test
+                        cipher = PKCS.new(key, randfunc=randGen(t2b(test[3])))
+                        ct = cipher.encrypt(b(test[1]))
+                        self.assertEqual(ct, t2b(test[2]))
+
+        def testEncrypt2(self):
+                # Verify that encryption fail if plaintext is too long
+                pt = '\x00'*(128-11+1)
+                cipher = PKCS.new(self.key1024)
+                self.assertRaises(ValueError, cipher.encrypt, pt)
+
+        def testVerify1(self):
+            for test in self._testData:
+                key = RSA.importKey(test[0])
+                expected_pt = b(test[1])
+                ct = t2b(test[2])
+                cipher = PKCS.new(key)
+
+                # The real test
+                pt = cipher.decrypt(ct, None)
+                self.assertEqual(pt, expected_pt)
+
+                pt = cipher.decrypt(ct, b'\xFF' * len(expected_pt))
+                self.assertEqual(pt, expected_pt)
+
+        def testVerify2(self):
+            # Verify that decryption fails if ciphertext is not as long as
+            # RSA modulus
+            cipher = PKCS.new(self.key1024)
+            self.assertRaises(ValueError, cipher.decrypt, '\x00'*127, "---")
+            self.assertRaises(ValueError, cipher.decrypt, '\x00'*129, "---")
+
+            # Verify that decryption fails if there are less then 8 non-zero padding
+            # bytes
+            pt = b('\x00\x02' + '\xFF'*7 + '\x00' + '\x45'*118)
+            pt_int = bytes_to_long(pt)
+            ct_int = self.key1024._encrypt(pt_int)
+            ct = long_to_bytes(ct_int, 128)
+            self.assertEqual(b"---", cipher.decrypt(ct, b"---"))
+
+        def testEncryptVerify1(self):
+            # Encrypt/Verify messages of length [0..RSAlen-11]
+            # and therefore padding [8..117]
+            for pt_len in range(0, 128 - 11 + 1):
+                pt = self.rng(pt_len)
+                cipher = PKCS.new(self.key1024)
+                ct = cipher.encrypt(pt)
+                pt2 = cipher.decrypt(ct, b'\xAA' * pt_len)
+                self.assertEqual(pt, pt2)
+
+        def test_encrypt_verify_exp_pt_len(self):
+
+            cipher = PKCS.new(self.key1024)
+            pt = b'5' * 16
+            ct = cipher.encrypt(pt)
+            sentinel = b'\xAA' * 16
+
+            pt_A = cipher.decrypt(ct, sentinel, 16)
+            self.assertEqual(pt, pt_A)
+
+            pt_B = cipher.decrypt(ct, sentinel, 15)
+            self.assertEqual(sentinel, pt_B)
+
+            pt_C = cipher.decrypt(ct, sentinel, 17)
+            self.assertEqual(sentinel, pt_C)
+
+        def testByteArray(self):
+            pt = b"XER"
+            cipher = PKCS.new(self.key1024)
+            ct = cipher.encrypt(bytearray(pt))
+            pt2 = cipher.decrypt(bytearray(ct), '\xFF' * len(pt))
+            self.assertEqual(pt, pt2)
+
+        def testMemoryview(self):
+            pt = b"XER"
+            cipher = PKCS.new(self.key1024)
+            ct = cipher.encrypt(memoryview(bytearray(pt)))
+            pt2 = cipher.decrypt(memoryview(bytearray(ct)), b'\xFF' * len(pt))
+            self.assertEqual(pt, pt2)
+
+        def test_return_type(self):
+            pt = b"XYZ"
+            cipher = PKCS.new(self.key1024)
+            ct = cipher.encrypt(pt)
+            self.assertTrue(isinstance(ct, bytes))
+            pt2 = cipher.decrypt(ct, b'\xAA' * 3)
+            self.assertTrue(isinstance(pt2, bytes))
+
+
+class TestVectorsWycheproof(unittest.TestCase):
+
+    def __init__(self, wycheproof_warnings, skip_slow_tests):
+        unittest.TestCase.__init__(self)
+        self._wycheproof_warnings = wycheproof_warnings
+        self._skip_slow_tests = skip_slow_tests
+        self._id = "None"
+
+    def load_tests(self, filename):
+
+        def filter_rsa(group):
+            return RSA.import_key(group['privateKeyPem'])
+
+        result = load_test_vectors_wycheproof(("Cipher", "wycheproof"),
+                                              filename,
+                                              "Wycheproof PKCS#1v1.5 (%s)" % filename,
+                                              group_tag={'rsa_key': filter_rsa}
+                                              )
+        return result
+
+    def setUp(self):
+        self.tv = []
+        self.tv.extend(self.load_tests("rsa_pkcs1_2048_test.json"))
+        if not self._skip_slow_tests:
+            self.tv.extend(self.load_tests("rsa_pkcs1_3072_test.json"))
+            self.tv.extend(self.load_tests("rsa_pkcs1_4096_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_decrypt(self, tv):
+        self._id = "Wycheproof Decrypt PKCS#1v1.5 Test #%s" % tv.id
+        sentinel = b'\xAA' * max(3, len(tv.msg))
+        cipher = PKCS.new(tv.rsa_key)
+        try:
+            pt = cipher.decrypt(tv.ct, sentinel=sentinel)
+        except ValueError:
+            assert not tv.valid
+        else:
+            if pt == sentinel:
+                assert not tv.valid
+            else:
+                assert tv.valid
+                self.assertEqual(pt, tv.msg)
+                self.warn(tv)
+
+    def runTest(self):
+
+        for tv in self.tv:
+            self.test_decrypt(tv)
+
+
+def get_tests(config={}):
+    skip_slow_tests = not config.get('slow_tests')
+    wycheproof_warnings = config.get('wycheproof_warnings')
+
+    tests = []
+    tests += list_test_cases(PKCS1_15_Tests)
+    tests += [TestVectorsWycheproof(wycheproof_warnings, skip_slow_tests)]
+    return tests
+
+
+if __name__ == '__main__':
+    def suite():
+        return unittest.TestSuite(get_tests())
+    unittest.main(defaultTest='suite')
+
+# vim:set ts=4 sw=4 sts=4 expandtab:

wemm/lib/python3.10/site-packages/Crypto/SelfTest/PublicKey/test_ElGamal.py

@@ -0,0 +1,217 @@
+# -*- coding: utf-8 -*-
+#
+#  SelfTest/PublicKey/test_ElGamal.py: Self-test for the ElGamal primitive
+#
+# ===================================================================
+# 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 suite for Crypto.PublicKey.ElGamal"""
+
+__revision__ = "$Id$"
+
+import unittest
+from Crypto.SelfTest.st_common import list_test_cases, a2b_hex, b2a_hex
+from Crypto import Random
+from Crypto.PublicKey import ElGamal
+from Crypto.Util.number import bytes_to_long
+from Crypto.Util.py3compat import *
+
+class ElGamalTest(unittest.TestCase):
+
+    #
+    # Test vectors
+    #
+    # There seem to be no real ElGamal test vectors available in the
+    # public domain. The following test vectors have been generated
+    # with libgcrypt 1.5.0.
+    #
+    # Encryption
+    tve=[
+        {
+        # 256 bits
+        'p'  :'BA4CAEAAED8CBE952AFD2126C63EB3B345D65C2A0A73D2A3AD4138B6D09BD933',
+        'g'  :'05',
+        'y'  :'60D063600ECED7C7C55146020E7A31C4476E9793BEAED420FEC9E77604CAE4EF',
+        'x'  :'1D391BA2EE3C37FE1BA175A69B2C73A11238AD77675932',
+        'k'  :'F5893C5BAB4131264066F57AB3D8AD89E391A0B68A68A1',
+        'pt' :'48656C6C6F207468657265',
+        'ct1':'32BFD5F487966CEA9E9356715788C491EC515E4ED48B58F0F00971E93AAA5EC7',
+        'ct2':'7BE8FBFF317C93E82FCEF9BD515284BA506603FEA25D01C0CB874A31F315EE68'
+        },
+
+        {
+        # 512 bits
+        'p'  :'F1B18AE9F7B4E08FDA9A04832F4E919D89462FD31BF12F92791A93519F75076D6CE3942689CDFF2F344CAFF0F82D01864F69F3AECF566C774CBACF728B81A227',
+        'g'  :'07',
+        'y'  :'688628C676E4F05D630E1BE39D0066178CA7AA83836B645DE5ADD359B4825A12B02EF4252E4E6FA9BEC1DB0BE90F6D7C8629CABB6E531F472B2664868156E20C',
+        'x'  :'14E60B1BDFD33436C0DA8A22FDC14A2CCDBBED0627CE68',
+        'k'  :'38DBF14E1F319BDA9BAB33EEEADCAF6B2EA5250577ACE7',
+        'pt' :'48656C6C6F207468657265',
+        'ct1':'290F8530C2CC312EC46178724F196F308AD4C523CEABB001FACB0506BFED676083FE0F27AC688B5C749AB3CB8A80CD6F7094DBA421FB19442F5A413E06A9772B',
+        'ct2':'1D69AAAD1DC50493FB1B8E8721D621D683F3BF1321BE21BC4A43E11B40C9D4D9C80DE3AAC2AB60D31782B16B61112E68220889D53C4C3136EE6F6CE61F8A23A0'
+        }
+    ]
+
+    # Signature
+    tvs=[
+        {
+        # 256 bits
+        'p'  :'D2F3C41EA66530838A704A48FFAC9334F4701ECE3A97CEE4C69DD01AE7129DD7',
+        'g'  :'05',
+        'y'  :'C3F9417DC0DAFEA6A05C1D2333B7A95E63B3F4F28CC962254B3256984D1012E7',
+        'x'  :'165E4A39BE44D5A2D8B1332D416BC559616F536BC735BB',
+        'k'  :'C7F0C794A7EAD726E25A47FF8928013680E73C51DD3D7D99BFDA8F492585928F',
+        'h'  :'48656C6C6F207468657265',
+        'sig1':'35CA98133779E2073EF31165AFCDEB764DD54E96ADE851715495F9C635E1E7C2',
+        'sig2':'0135B88B1151279FE5D8078D4FC685EE81177EE9802AB123A73925FC1CB059A7',
+        },
+        {
+        # 512 bits
+        'p'  :'E24CF3A4B8A6AF749DCA6D714282FE4AABEEE44A53BB6ED15FBE32B5D3C3EF9CC4124A2ECA331F3C1C1B667ACA3766825217E7B5F9856648D95F05330C6A19CF',
+        'g'  :'0B',
+        'y'  :'2AD3A1049CA5D4ED207B2431C79A8719BB4073D4A94E450EA6CEE8A760EB07ADB67C0D52C275EE85D7B52789061EE45F2F37D9B2AE522A51C28329766BFE68AC',
+        'x'  :'16CBB4F46D9ECCF24FF9F7E63CAA3BD8936341555062AB',
+        'k'  :'8A3D89A4E429FD2476D7D717251FB79BF900FFE77444E6BB8299DC3F84D0DD57ABAB50732AE158EA52F5B9E7D8813E81FD9F79470AE22F8F1CF9AEC820A78C69',
+        'h'  :'48656C6C6F207468657265',
+        'sig1':'BE001AABAFFF976EC9016198FBFEA14CBEF96B000CCC0063D3324016F9E91FE80D8F9325812ED24DDB2B4D4CF4430B169880B3CE88313B53255BD4EC0378586F',
+        'sig2':'5E266F3F837BA204E3BBB6DBECC0611429D96F8C7CE8F4EFDF9D4CB681C2A954468A357BF4242CEC7418B51DFC081BCD21299EF5B5A0DDEF3A139A1817503DDE',
+        }
+    ]
+
+    def test_generate_180(self):
+        self._test_random_key(180)
+
+    def test_encryption(self):
+        for tv in self.tve:
+            d = self.convert_tv(tv, True)
+            key = ElGamal.construct(d['key'])
+            ct = key._encrypt(d['pt'], d['k'])
+            self.assertEqual(ct[0], d['ct1'])
+            self.assertEqual(ct[1], d['ct2'])
+
+    def test_decryption(self):
+        for tv in self.tve:
+            d = self.convert_tv(tv, True)
+            key = ElGamal.construct(d['key'])
+            pt = key._decrypt((d['ct1'], d['ct2']))
+            self.assertEqual(pt, d['pt'])
+
+    def test_signing(self):
+        for tv in self.tvs:
+            d = self.convert_tv(tv, True)
+            key = ElGamal.construct(d['key'])
+            sig1, sig2 = key._sign(d['h'], d['k'])
+            self.assertEqual(sig1, d['sig1'])
+            self.assertEqual(sig2, d['sig2'])
+
+    def test_verification(self):
+        for tv in self.tvs:
+            d = self.convert_tv(tv, True)
+            key = ElGamal.construct(d['key'])
+            # Positive test
+            res = key._verify( d['h'], (d['sig1'],d['sig2']) )
+            self.assertTrue(res)
+            # Negative test
+            res = key._verify( d['h'], (d['sig1']+1,d['sig2']) )
+            self.assertFalse(res)
+
+    def test_bad_key3(self):
+        tup = tup0 = list(self.convert_tv(self.tvs[0], 1)['key'])[:3]
+        tup[0] += 1 # p += 1 (not prime)
+        self.assertRaises(ValueError, ElGamal.construct, tup)
+
+        tup = tup0
+        tup[1] = 1 # g = 1
+        self.assertRaises(ValueError, ElGamal.construct, tup)
+
+        tup = tup0
+        tup[2] = tup[0]*2 # y = 2*p
+        self.assertRaises(ValueError, ElGamal.construct, tup)
+
+    def test_bad_key4(self):
+        tup = tup0 = list(self.convert_tv(self.tvs[0], 1)['key'])
+        tup[3] += 1 # x += 1
+        self.assertRaises(ValueError, ElGamal.construct, tup)
+
+    def convert_tv(self, tv, as_longs=0):
+        """Convert a test vector from textual form (hexadecimal ascii
+        to either integers or byte strings."""
+        key_comps = 'p','g','y','x'
+        tv2 = {}
+        for c in tv.keys():
+            tv2[c] = a2b_hex(tv[c])
+            if as_longs or c in key_comps or c in ('sig1','sig2'):
+                tv2[c] = bytes_to_long(tv2[c])
+        tv2['key']=[]
+        for c in key_comps:
+            tv2['key'] += [tv2[c]]
+            del tv2[c]
+        return tv2
+
+    def _test_random_key(self, bits):
+        elgObj = ElGamal.generate(bits, Random.new().read)
+        self._check_private_key(elgObj)
+        self._exercise_primitive(elgObj)
+        pub = elgObj.publickey()
+        self._check_public_key(pub)
+        self._exercise_public_primitive(elgObj)
+
+    def _check_private_key(self, elgObj):
+
+        # Check capabilities
+        self.assertTrue(elgObj.has_private())
+
+        # Sanity check key data
+        self.assertTrue(1<elgObj.g<(elgObj.p-1))
+        self.assertEqual(pow(elgObj.g, elgObj.p-1, elgObj.p), 1)
+        self.assertTrue(1<elgObj.x<(elgObj.p-1))
+        self.assertEqual(pow(elgObj.g, elgObj.x, elgObj.p), elgObj.y)
+
+    def _check_public_key(self, elgObj):
+
+        # Check capabilities
+        self.assertFalse(elgObj.has_private())
+
+        # Sanity check key data
+        self.assertTrue(1<elgObj.g<(elgObj.p-1))
+        self.assertEqual(pow(elgObj.g, elgObj.p-1, elgObj.p), 1)
+
+    def _exercise_primitive(self, elgObj):
+        # Test encryption/decryption
+        plaintext = 127218
+        ciphertext = elgObj._encrypt(plaintext, 123456789)
+        plaintextP = elgObj._decrypt(ciphertext)
+        self.assertEqual(plaintext, plaintextP)
+
+        # Test signature/verification
+        signature = elgObj._sign(plaintext, 987654321)
+        elgObj._verify(plaintext, signature)
+
+    def _exercise_public_primitive(self, elgObj):
+        plaintext = 92987276
+        ciphertext = elgObj._encrypt(plaintext, 123456789)
+
+def get_tests(config={}):
+    tests = []
+    tests += list_test_cases(ElGamalTest)
+    return tests
+
+if __name__ == '__main__':
+    suite = lambda: unittest.TestSuite(get_tests())
+    unittest.main(defaultTest='suite')
+

wemm/lib/python3.10/site-packages/Crypto/Signature/DSS.py

@@ -0,0 +1,403 @@
+#
+#  Signature/DSS.py : DSS.py
+#
+# ===================================================================
+#
+# 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.asn1 import DerSequence
+from Crypto.Util.number import long_to_bytes
+from Crypto.Math.Numbers import Integer
+
+from Crypto.Hash import HMAC
+from Crypto.PublicKey.ECC import EccKey
+from Crypto.PublicKey.DSA import DsaKey
+
+__all__ = ['DssSigScheme', 'new']
+
+
+class DssSigScheme(object):
+    """A (EC)DSA signature object.
+    Do not instantiate directly.
+    Use :func:`Crypto.Signature.DSS.new`.
+    """
+
+    def __init__(self, key, encoding, order):
+        """Create a new Digital Signature Standard (DSS) object.
+
+        Do not instantiate this object directly,
+        use `Crypto.Signature.DSS.new` instead.
+        """
+
+        self._key = key
+        self._encoding = encoding
+        self._order = order
+
+        self._order_bits = self._order.size_in_bits()
+        self._order_bytes = (self._order_bits - 1) // 8 + 1
+
+    def can_sign(self):
+        """Return ``True`` if this signature object can be used
+        for signing messages."""
+
+        return self._key.has_private()
+
+    def _compute_nonce(self, msg_hash):
+        raise NotImplementedError("To be provided by subclasses")
+
+    def _valid_hash(self, msg_hash):
+        raise NotImplementedError("To be provided by subclasses")
+
+    def sign(self, msg_hash):
+        """Compute the DSA/ECDSA signature of a message.
+
+        Args:
+          msg_hash (hash object):
+            The hash that was carried out over the message.
+            The object belongs to the :mod:`Crypto.Hash` package.
+            Under mode ``'fips-186-3'``, the hash must be a FIPS
+            approved secure hash (SHA-2 or SHA-3).
+
+        :return: The signature as ``bytes``
+        :raise ValueError: if the hash algorithm is incompatible to the (EC)DSA key
+        :raise TypeError: if the (EC)DSA key has no private half
+        """
+
+        if not self._key.has_private():
+            raise TypeError("Private key is needed to sign")
+
+        if not self._valid_hash(msg_hash):
+            raise ValueError("Hash is not sufficiently strong")
+
+        # Generate the nonce k (critical!)
+        nonce = self._compute_nonce(msg_hash)
+
+        # Perform signature using the raw API
+        z = Integer.from_bytes(msg_hash.digest()[:self._order_bytes])
+        sig_pair = self._key._sign(z, nonce)
+
+        # Encode the signature into a single byte string
+        if self._encoding == 'binary':
+            output = b"".join([long_to_bytes(x, self._order_bytes)
+                               for x in sig_pair])
+        else:
+            # Dss-sig  ::=  SEQUENCE  {
+            #   r   INTEGER,
+            #   s   INTEGER
+            # }
+            # Ecdsa-Sig-Value  ::=  SEQUENCE  {
+            #   r   INTEGER,
+            #   s   INTEGER
+            # }
+            output = DerSequence(sig_pair).encode()
+
+        return output
+
+    def verify(self, msg_hash, signature):
+        """Check if a certain (EC)DSA signature is authentic.
+
+        Args:
+          msg_hash (hash object):
+            The hash that was carried out over the message.
+            This is an object belonging to the :mod:`Crypto.Hash` module.
+            Under mode ``'fips-186-3'``, the hash must be a FIPS
+            approved secure hash (SHA-2 or SHA-3).
+
+          signature (``bytes``):
+            The signature that needs to be validated.
+
+        :raise ValueError: if the signature is not authentic
+        """
+
+        if not self._valid_hash(msg_hash):
+            raise ValueError("Hash is not sufficiently strong")
+
+        if self._encoding == 'binary':
+            if len(signature) != (2 * self._order_bytes):
+                raise ValueError("The signature is not authentic (length)")
+            r_prime, s_prime = [Integer.from_bytes(x)
+                                for x in (signature[:self._order_bytes],
+                                          signature[self._order_bytes:])]
+        else:
+            try:
+                der_seq = DerSequence().decode(signature, strict=True)
+            except (ValueError, IndexError):
+                raise ValueError("The signature is not authentic (DER)")
+            if len(der_seq) != 2 or not der_seq.hasOnlyInts():
+                raise ValueError("The signature is not authentic (DER content)")
+            r_prime, s_prime = Integer(der_seq[0]), Integer(der_seq[1])
+
+        if not (0 < r_prime < self._order) or not (0 < s_prime < self._order):
+            raise ValueError("The signature is not authentic (d)")
+
+        z = Integer.from_bytes(msg_hash.digest()[:self._order_bytes])
+        result = self._key._verify(z, (r_prime, s_prime))
+        if not result:
+            raise ValueError("The signature is not authentic")
+        # Make PyCrypto code to fail
+        return False
+
+
+class DeterministicDsaSigScheme(DssSigScheme):
+    # Also applicable to ECDSA
+
+    def __init__(self, key, encoding, order, private_key):
+        super(DeterministicDsaSigScheme, self).__init__(key, encoding, order)
+        self._private_key = private_key
+
+    def _bits2int(self, bstr):
+        """See 2.3.2 in RFC6979"""
+
+        result = Integer.from_bytes(bstr)
+        q_len = self._order.size_in_bits()
+        b_len = len(bstr) * 8
+        if b_len > q_len:
+            # Only keep leftmost q_len bits
+            result >>= (b_len - q_len)
+        return result
+
+    def _int2octets(self, int_mod_q):
+        """See 2.3.3 in RFC6979"""
+
+        assert 0 < int_mod_q < self._order
+        return long_to_bytes(int_mod_q, self._order_bytes)
+
+    def _bits2octets(self, bstr):
+        """See 2.3.4 in RFC6979"""
+
+        z1 = self._bits2int(bstr)
+        if z1 < self._order:
+            z2 = z1
+        else:
+            z2 = z1 - self._order
+        return self._int2octets(z2)
+
+    def _compute_nonce(self, mhash):
+        """Generate k in a deterministic way"""
+
+        # See section 3.2 in RFC6979.txt
+        # Step a
+        h1 = mhash.digest()
+        # Step b
+        mask_v = b'\x01' * mhash.digest_size
+        # Step c
+        nonce_k = b'\x00' * mhash.digest_size
+
+        for int_oct in (b'\x00', b'\x01'):
+            # Step d/f
+            nonce_k = HMAC.new(nonce_k,
+                               mask_v + int_oct +
+                               self._int2octets(self._private_key) +
+                               self._bits2octets(h1), mhash).digest()
+            # Step e/g
+            mask_v = HMAC.new(nonce_k, mask_v, mhash).digest()
+
+        nonce = -1
+        while not (0 < nonce < self._order):
+            # Step h.C (second part)
+            if nonce != -1:
+                nonce_k = HMAC.new(nonce_k, mask_v + b'\x00',
+                                   mhash).digest()
+                mask_v = HMAC.new(nonce_k, mask_v, mhash).digest()
+
+            # Step h.A
+            mask_t = b""
+
+            # Step h.B
+            while len(mask_t) < self._order_bytes:
+                mask_v = HMAC.new(nonce_k, mask_v, mhash).digest()
+                mask_t += mask_v
+
+            # Step h.C (first part)
+            nonce = self._bits2int(mask_t)
+        return nonce
+
+    def _valid_hash(self, msg_hash):
+        return True
+
+
+class FipsDsaSigScheme(DssSigScheme):
+
+    #: List of L (bit length of p) and N (bit length of q) combinations
+    #: that are allowed by FIPS 186-3. The security level is provided in
+    #: Table 2 of FIPS 800-57 (rev3).
+    _fips_186_3_L_N = (
+                        (1024, 160),    # 80 bits  (SHA-1 or stronger)
+                        (2048, 224),    # 112 bits (SHA-224 or stronger)
+                        (2048, 256),    # 128 bits (SHA-256 or stronger)
+                        (3072, 256)     # 256 bits (SHA-512)
+                      )
+
+    def __init__(self, key, encoding, order, randfunc):
+        super(FipsDsaSigScheme, self).__init__(key, encoding, order)
+        self._randfunc = randfunc
+
+        L = Integer(key.p).size_in_bits()
+        if (L, self._order_bits) not in self._fips_186_3_L_N:
+            error = ("L/N (%d, %d) is not compliant to FIPS 186-3"
+                     % (L, self._order_bits))
+            raise ValueError(error)
+
+    def _compute_nonce(self, msg_hash):
+        # hash is not used
+        return Integer.random_range(min_inclusive=1,
+                                    max_exclusive=self._order,
+                                    randfunc=self._randfunc)
+
+    def _valid_hash(self, msg_hash):
+        """Verify that SHA-1, SHA-2 or SHA-3 are used"""
+        return (msg_hash.oid == "1.3.14.3.2.26" or
+                msg_hash.oid.startswith("2.16.840.1.101.3.4.2."))
+
+
+class FipsEcDsaSigScheme(DssSigScheme):
+
+    def __init__(self, key, encoding, order, randfunc):
+        super(FipsEcDsaSigScheme, self).__init__(key, encoding, order)
+        self._randfunc = randfunc
+
+    def _compute_nonce(self, msg_hash):
+        return Integer.random_range(min_inclusive=1,
+                                    max_exclusive=self._key._curve.order,
+                                    randfunc=self._randfunc)
+
+    def _valid_hash(self, msg_hash):
+        """Verify that the strength of the hash matches or exceeds
+        the strength of the EC. We fail if the hash is too weak."""
+
+        modulus_bits = self._key.pointQ.size_in_bits()
+
+        # SHS: SHA-2, SHA-3, truncated SHA-512
+        sha224 = ("2.16.840.1.101.3.4.2.4", "2.16.840.1.101.3.4.2.7", "2.16.840.1.101.3.4.2.5")
+        sha256 = ("2.16.840.1.101.3.4.2.1", "2.16.840.1.101.3.4.2.8", "2.16.840.1.101.3.4.2.6")
+        sha384 = ("2.16.840.1.101.3.4.2.2", "2.16.840.1.101.3.4.2.9")
+        sha512 = ("2.16.840.1.101.3.4.2.3", "2.16.840.1.101.3.4.2.10")
+        shs = sha224 + sha256 + sha384 + sha512
+
+        try:
+            result = msg_hash.oid in shs
+        except AttributeError:
+            result = False
+        return result
+
+
+def new(key, mode, encoding='binary', randfunc=None):
+    """Create a signature object :class:`DssSigScheme` that
+    can perform (EC)DSA signature or verification.
+
+    .. note::
+        Refer to `NIST SP 800 Part 1 Rev 4`_ (or newer release) for an
+        overview of the recommended key lengths.
+
+    Args:
+        key (:class:`Crypto.PublicKey.DSA` or :class:`Crypto.PublicKey.ECC`):
+            The key to use for computing the signature (*private* keys only)
+            or for verifying one.
+            For DSA keys, let ``L`` and ``N`` be the bit lengths of the modulus ``p``
+            and of ``q``: the pair ``(L,N)`` must appear in the following list,
+            in compliance to section 4.2 of `FIPS 186-4`_:
+
+            - (1024, 160) *legacy only; do not create new signatures with this*
+            - (2048, 224) *deprecated; do not create new signatures with this*
+            - (2048, 256)
+            - (3072, 256)
+
+            For ECC, only keys over P-224, P-256, P-384, and P-521 are accepted.
+
+        mode (string):
+            The parameter can take these values:
+
+            - ``'fips-186-3'``. The signature generation is randomized and carried out
+              according to `FIPS 186-3`_: the nonce ``k`` is taken from the RNG.
+            - ``'deterministic-rfc6979'``. The signature generation is not
+              randomized. See RFC6979_.
+
+        encoding (string):
+            How the signature is encoded. This value determines the output of
+            :meth:`sign` and the input to :meth:`verify`.
+
+            The following values are accepted:
+
+            - ``'binary'`` (default), the signature is the raw concatenation
+              of ``r`` and ``s``. It is defined in the IEEE P.1363 standard.
+              For DSA, the size in bytes of the signature is ``N/4`` bytes
+              (e.g. 64 for ``N=256``).
+              For ECDSA, the signature is always twice the length of a point
+              coordinate (e.g. 64 bytes for P-256).
+
+            - ``'der'``, the signature is a ASN.1 DER SEQUENCE
+              with two INTEGERs (``r`` and ``s``). It is defined in RFC3279_.
+              The size of the signature is variable.
+
+        randfunc (callable):
+            A function that returns random ``bytes``, of a given length.
+            If omitted, the internal RNG is used.
+            Only applicable for the *'fips-186-3'* mode.
+
+    .. _FIPS 186-3: http://csrc.nist.gov/publications/fips/fips186-3/fips_186-3.pdf
+    .. _FIPS 186-4: http://nvlpubs.nist.gov/nistpubs/FIPS/NIST.FIPS.186-4.pdf
+    .. _NIST SP 800 Part 1 Rev 4: http://nvlpubs.nist.gov/nistpubs/SpecialPublications/NIST.SP.800-57pt1r4.pdf
+    .. _RFC6979: http://tools.ietf.org/html/rfc6979
+    .. _RFC3279: https://tools.ietf.org/html/rfc3279#section-2.2.2
+    """
+
+    # The goal of the 'mode' parameter is to avoid to
+    # have the current version of the standard as default.
+    #
+    # Over time, such version will be superseded by (for instance)
+    # FIPS 186-4 and it will be odd to have -3 as default.
+
+    if encoding not in ('binary', 'der'):
+        raise ValueError("Unknown encoding '%s'" % encoding)
+
+    if isinstance(key, EccKey):
+        order = key._curve.order
+        private_key_attr = 'd'
+        if not key.curve.startswith("NIST"):
+            raise ValueError("ECC key is not on a NIST P curve")
+    elif isinstance(key, DsaKey):
+        order = Integer(key.q)
+        private_key_attr = 'x'
+    else:
+        raise ValueError("Unsupported key type " + str(type(key)))
+
+    if key.has_private():
+        private_key = getattr(key, private_key_attr)
+    else:
+        private_key = None
+
+    if mode == 'deterministic-rfc6979':
+        return DeterministicDsaSigScheme(key, encoding, order, private_key)
+    elif mode == 'fips-186-3':
+        if isinstance(key, EccKey):
+            return FipsEcDsaSigScheme(key, encoding, order, randfunc)
+        else:
+            return FipsDsaSigScheme(key, encoding, order, randfunc)
+    else:
+        raise ValueError("Unknown DSS mode '%s'" % mode)

wemm/lib/python3.10/site-packages/Crypto/Signature/DSS.pyi

@@ -0,0 +1,27 @@
+from typing import Union, Optional, Callable
+from typing_extensions import Protocol
+
+from Crypto.PublicKey.DSA import DsaKey
+from Crypto.PublicKey.ECC import EccKey
+
+class Hash(Protocol):
+    def digest(self) -> bytes: ...
+
+__all__ = ['new']
+
+class DssSigScheme:
+    def __init__(self, key: Union[DsaKey, EccKey], encoding: str, order: int) -> None: ...
+    def can_sign(self) -> bool: ...
+    def sign(self, msg_hash: Hash) -> bytes: ...
+    def verify(self, msg_hash: Hash, signature: bytes) -> bool: ...
+
+class DeterministicDsaSigScheme(DssSigScheme):
+    def __init__(self, key, encoding, order, private_key) -> None: ...
+
+class FipsDsaSigScheme(DssSigScheme):
+    def __init__(self, key: DsaKey, encoding: str, order: int, randfunc: Callable) -> None: ...
+
+class FipsEcDsaSigScheme(DssSigScheme):
+    def __init__(self, key: EccKey, encoding: str, order: int, randfunc: Callable) -> None: ...
+
+def new(key: Union[DsaKey, EccKey], mode: str, encoding: Optional[str]='binary', randfunc: Optional[Callable]=None) -> Union[DeterministicDsaSigScheme, FipsDsaSigScheme, FipsEcDsaSigScheme]: ...

wemm/lib/python3.10/site-packages/Crypto/Signature/eddsa.py

@@ -0,0 +1,343 @@
+# ===================================================================
+#
+# Copyright (c) 2022, 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.Math.Numbers import Integer
+
+from Crypto.Hash import SHA512, SHAKE256
+from Crypto.Util.py3compat import bchr, is_bytes
+from Crypto.PublicKey.ECC import (EccKey,
+                                  construct,
+                                  _import_ed25519_public_key,
+                                  _import_ed448_public_key)
+
+
+def import_public_key(encoded):
+    """Create a new Ed25519 or Ed448 public key object,
+    starting from the key encoded as raw ``bytes``,
+    in the format described in RFC8032.
+
+    Args:
+      encoded (bytes):
+        The EdDSA public key to import.
+        It must be 32 bytes for Ed25519, and 57 bytes for Ed448.
+
+    Returns:
+      :class:`Crypto.PublicKey.EccKey` : a new ECC key object.
+
+    Raises:
+      ValueError: when the given key cannot be parsed.
+    """
+
+    if len(encoded) == 32:
+        x, y = _import_ed25519_public_key(encoded)
+        curve_name = "Ed25519"
+    elif len(encoded) == 57:
+        x, y = _import_ed448_public_key(encoded)
+        curve_name = "Ed448"
+    else:
+        raise ValueError("Not an EdDSA key (%d bytes)" % len(encoded))
+    return construct(curve=curve_name, point_x=x, point_y=y)
+
+
+def import_private_key(encoded):
+    """Create a new Ed25519 or Ed448 private key object,
+    starting from the key encoded as raw ``bytes``,
+    in the format described in RFC8032.
+
+    Args:
+      encoded (bytes):
+        The EdDSA private key to import.
+        It must be 32 bytes for Ed25519, and 57 bytes for Ed448.
+
+    Returns:
+      :class:`Crypto.PublicKey.EccKey` : a new ECC key object.
+
+    Raises:
+      ValueError: when the given key cannot be parsed.
+    """
+
+    if len(encoded) == 32:
+        curve_name = "ed25519"
+    elif len(encoded) == 57:
+        curve_name = "ed448"
+    else:
+        raise ValueError("Incorrect length. Only EdDSA private keys are supported.")
+
+    # Note that the private key is truly a sequence of random bytes,
+    # so we cannot check its correctness in any way.
+
+    return construct(seed=encoded, curve=curve_name)
+
+
+class EdDSASigScheme(object):
+    """An EdDSA signature object.
+    Do not instantiate directly.
+    Use :func:`Crypto.Signature.eddsa.new`.
+    """
+
+    def __init__(self, key, context):
+        """Create a new EdDSA object.
+
+        Do not instantiate this object directly,
+        use `Crypto.Signature.DSS.new` instead.
+        """
+
+        self._key = key
+        self._context = context
+        self._A = key._export_eddsa_public()
+        self._order = key._curve.order
+
+    def can_sign(self):
+        """Return ``True`` if this signature object can be used
+        for signing messages."""
+
+        return self._key.has_private()
+
+    def sign(self, msg_or_hash):
+        """Compute the EdDSA signature of a message.
+
+        Args:
+          msg_or_hash (bytes or a hash object):
+            The message to sign (``bytes``, in case of *PureEdDSA*) or
+            the hash that was carried out over the message (hash object, for *HashEdDSA*).
+
+            The hash object must be :class:`Crypto.Hash.SHA512` for Ed25519,
+            and :class:`Crypto.Hash.SHAKE256` object for Ed448.
+
+        :return: The signature as ``bytes``. It is always 64 bytes for Ed25519, and 114 bytes for Ed448.
+        :raise TypeError: if the EdDSA key has no private half
+        """
+
+        if not self._key.has_private():
+            raise TypeError("Private key is needed to sign")
+
+        if self._key.curve == "Ed25519":
+            ph = isinstance(msg_or_hash, SHA512.SHA512Hash)
+            if not (ph or is_bytes(msg_or_hash)):
+                raise TypeError("'msg_or_hash' must be bytes of a SHA-512 hash")
+            eddsa_sign_method = self._sign_ed25519
+
+        elif self._key.curve == "Ed448":
+            ph = isinstance(msg_or_hash, SHAKE256.SHAKE256_XOF)
+            if not (ph or is_bytes(msg_or_hash)):
+                raise TypeError("'msg_or_hash' must be bytes of a SHAKE256 hash")
+            eddsa_sign_method = self._sign_ed448
+
+        else:
+            raise ValueError("Incorrect curve for EdDSA")
+
+        return eddsa_sign_method(msg_or_hash, ph)
+
+    def _sign_ed25519(self, msg_or_hash, ph):
+
+        if self._context or ph:
+            flag = int(ph)
+            # dom2(flag, self._context)
+            dom2 = b'SigEd25519 no Ed25519 collisions' + bchr(flag) + \
+                   bchr(len(self._context)) + self._context
+        else:
+            dom2 = b''
+
+        PHM = msg_or_hash.digest() if ph else msg_or_hash
+
+        # See RFC 8032, section 5.1.6
+
+        # Step 2
+        r_hash = SHA512.new(dom2 + self._key._prefix + PHM).digest()
+        r = Integer.from_bytes(r_hash, 'little') % self._order
+        # Step 3
+        R_pk = EccKey(point=r * self._key._curve.G)._export_eddsa_public()
+        # Step 4
+        k_hash = SHA512.new(dom2 + R_pk + self._A + PHM).digest()
+        k = Integer.from_bytes(k_hash, 'little') % self._order
+        # Step 5
+        s = (r + k * self._key.d) % self._order
+
+        return R_pk + s.to_bytes(32, 'little')
+
+    def _sign_ed448(self, msg_or_hash, ph):
+
+        flag = int(ph)
+        # dom4(flag, self._context)
+        dom4 = b'SigEd448' + bchr(flag) + \
+               bchr(len(self._context)) + self._context
+
+        PHM = msg_or_hash.read(64) if ph else msg_or_hash
+
+        # See RFC 8032, section 5.2.6
+
+        # Step 2
+        r_hash = SHAKE256.new(dom4 + self._key._prefix + PHM).read(114)
+        r = Integer.from_bytes(r_hash, 'little') % self._order
+        # Step 3
+        R_pk = EccKey(point=r * self._key._curve.G)._export_eddsa_public()
+        # Step 4
+        k_hash = SHAKE256.new(dom4 + R_pk + self._A + PHM).read(114)
+        k = Integer.from_bytes(k_hash, 'little') % self._order
+        # Step 5
+        s = (r + k * self._key.d) % self._order
+
+        return R_pk + s.to_bytes(57, 'little')
+
+    def verify(self, msg_or_hash, signature):
+        """Check if an EdDSA signature is authentic.
+
+        Args:
+          msg_or_hash (bytes or a hash object):
+            The message to verify (``bytes``, in case of *PureEdDSA*) or
+            the hash that was carried out over the message (hash object, for *HashEdDSA*).
+
+            The hash object must be :class:`Crypto.Hash.SHA512` object for Ed25519,
+            and :class:`Crypto.Hash.SHAKE256` for Ed448.
+
+          signature (``bytes``):
+            The signature that needs to be validated.
+            It must be 64 bytes for Ed25519, and 114 bytes for Ed448.
+
+        :raise ValueError: if the signature is not authentic
+        """
+
+        if self._key.curve == "Ed25519":
+            ph = isinstance(msg_or_hash, SHA512.SHA512Hash)
+            if not (ph or is_bytes(msg_or_hash)):
+                raise TypeError("'msg_or_hash' must be bytes of a SHA-512 hash")
+            eddsa_verify_method = self._verify_ed25519
+
+        elif self._key.curve == "Ed448":
+            ph = isinstance(msg_or_hash, SHAKE256.SHAKE256_XOF)
+            if not (ph or is_bytes(msg_or_hash)):
+                raise TypeError("'msg_or_hash' must be bytes of a SHAKE256 hash")
+            eddsa_verify_method = self._verify_ed448
+
+        else:
+            raise ValueError("Incorrect curve for EdDSA")
+
+        return eddsa_verify_method(msg_or_hash, signature, ph)
+
+    def _verify_ed25519(self, msg_or_hash, signature, ph):
+
+        if len(signature) != 64:
+            raise ValueError("The signature is not authentic (length)")
+
+        if self._context or ph:
+            flag = int(ph)
+            dom2 = b'SigEd25519 no Ed25519 collisions' + bchr(flag) + \
+                   bchr(len(self._context)) + self._context
+        else:
+            dom2 = b''
+
+        PHM = msg_or_hash.digest() if ph else msg_or_hash
+
+        # Section 5.1.7
+
+        # Step 1
+        try:
+            R = import_public_key(signature[:32]).pointQ
+        except ValueError:
+            raise ValueError("The signature is not authentic (R)")
+        s = Integer.from_bytes(signature[32:], 'little')
+        if s > self._order:
+            raise ValueError("The signature is not authentic (S)")
+        # Step 2
+        k_hash = SHA512.new(dom2 + signature[:32] + self._A + PHM).digest()
+        k = Integer.from_bytes(k_hash, 'little') % self._order
+        # Step 3
+        point1 = s * 8 * self._key._curve.G
+        # OPTIMIZE: with double-scalar multiplication, with no SCA
+        # countermeasures because it is public values
+        point2 = 8 * R + k * 8 * self._key.pointQ
+        if point1 != point2:
+            raise ValueError("The signature is not authentic")
+
+    def _verify_ed448(self, msg_or_hash, signature, ph):
+
+        if len(signature) != 114:
+            raise ValueError("The signature is not authentic (length)")
+
+        flag = int(ph)
+        # dom4(flag, self._context)
+        dom4 = b'SigEd448' + bchr(flag) + \
+               bchr(len(self._context)) + self._context
+
+        PHM = msg_or_hash.read(64) if ph else msg_or_hash
+
+        # Section 5.2.7
+
+        # Step 1
+        try:
+            R = import_public_key(signature[:57]).pointQ
+        except ValueError:
+            raise ValueError("The signature is not authentic (R)")
+        s = Integer.from_bytes(signature[57:], 'little')
+        if s > self._order:
+            raise ValueError("The signature is not authentic (S)")
+        # Step 2
+        k_hash = SHAKE256.new(dom4 + signature[:57] + self._A + PHM).read(114)
+        k = Integer.from_bytes(k_hash, 'little') % self._order
+        # Step 3
+        point1 = s * 8 * self._key._curve.G
+        # OPTIMIZE: with double-scalar multiplication, with no SCA
+        # countermeasures because it is public values
+        point2 = 8 * R + k * 8 * self._key.pointQ
+        if point1 != point2:
+            raise ValueError("The signature is not authentic")
+
+
+def new(key, mode, context=None):
+    """Create a signature object :class:`EdDSASigScheme` that
+    can perform or verify an EdDSA signature.
+
+    Args:
+        key (:class:`Crypto.PublicKey.ECC` object):
+            The key to use for computing the signature (*private* keys only)
+            or for verifying one.
+            The key must be on the curve ``Ed25519`` or ``Ed448``.
+
+        mode (string):
+            This parameter must be ``'rfc8032'``.
+
+        context (bytes):
+            Up to 255 bytes of `context <https://datatracker.ietf.org/doc/html/rfc8032#page-41>`_,
+            which is a constant byte string to segregate different protocols or
+            different applications of the same key.
+    """
+
+    if not isinstance(key, EccKey) or key.curve not in ("Ed25519", "Ed448"):
+        raise ValueError("EdDSA can only be used with EdDSA keys")
+
+    if mode != 'rfc8032':
+        raise ValueError("Mode must be 'rfc8032'")
+
+    if context is None:
+        context = b''
+    elif len(context) > 255:
+        raise ValueError("Context for EdDSA must not be longer than 255 bytes")
+
+    return EdDSASigScheme(key, context)

wemm/lib/python3.10/site-packages/Crypto/Signature/eddsa.pyi

@@ -0,0 +1,21 @@
+from typing import Union, Optional
+from typing_extensions import Protocol
+from Crypto.PublicKey.ECC import EccKey
+
+class Hash(Protocol):
+    def digest(self) -> bytes: ...
+
+class XOF(Protocol):
+    def read(self, len: int) -> bytes: ...
+
+def import_public_key(encoded: bytes) -> EccKey: ...
+def import_private_key(encoded: bytes) -> EccKey: ...
+
+class EdDSASigScheme(object):
+
+    def __init__(self, key: EccKey, context: bytes) -> None: ...
+    def can_sign(self) -> bool: ...
+    def sign(self, msg_or_hash: Union[bytes, Hash, XOF]) -> bytes: ...
+    def verify(self, msg_or_hash: Union[bytes, Hash, XOF], signature: bytes) -> None: ...
+
+def new(key: EccKey, mode: str, context: Optional[bytes]=None) -> EdDSASigScheme: ...

wemm/lib/python3.10/site-packages/Crypto/Signature/pss.py

@@ -0,0 +1,387 @@
+# ===================================================================
+#
+# 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 bchr, bord, iter_range
+import Crypto.Util.number
+from Crypto.Util.number import (ceil_div,
+                                long_to_bytes,
+                                bytes_to_long
+                                )
+from Crypto.Util.strxor import strxor
+from Crypto import Random
+
+
+class PSS_SigScheme:
+    """A signature object for ``RSASSA-PSS``.
+    Do not instantiate directly.
+    Use :func:`Crypto.Signature.pss.new`.
+    """
+
+    def __init__(self, key, mgfunc, saltLen, randfunc):
+        """Initialize this PKCS#1 PSS signature scheme object.
+
+        :Parameters:
+          key : an RSA key object
+            If a private half is given, both signature and
+            verification are possible.
+            If a public half is given, only verification is possible.
+          mgfunc : callable
+            A mask generation function that accepts two parameters:
+            a string to use as seed, and the lenth of the mask to
+            generate, in bytes.
+          saltLen : integer
+            Length of the salt, in bytes.
+          randfunc : callable
+            A function that returns random bytes.
+        """
+
+        self._key = key
+        self._saltLen = saltLen
+        self._mgfunc = mgfunc
+        self._randfunc = randfunc
+
+    def can_sign(self):
+        """Return ``True`` if this object can be used to sign messages."""
+        return self._key.has_private()
+
+    def sign(self, msg_hash):
+        """Create the PKCS#1 PSS signature of a message.
+
+        This function is also called ``RSASSA-PSS-SIGN`` and
+        it is specified in
+        `section 8.1.1 of RFC8017 <https://tools.ietf.org/html/rfc8017#section-8.1.1>`_.
+
+        :parameter msg_hash:
+            This is an object from the :mod:`Crypto.Hash` package.
+            It has been used to digest the message to sign.
+        :type msg_hash: hash object
+
+        :return: the signature encoded as a *byte string*.
+        :raise ValueError: if the RSA key is not long enough for the given hash algorithm.
+        :raise TypeError: if the RSA key has no private half.
+        """
+
+        # Set defaults for salt length and mask generation function
+        if self._saltLen is None:
+            sLen = msg_hash.digest_size
+        else:
+            sLen = self._saltLen
+
+        if self._mgfunc is None:
+            mgf = lambda x, y: MGF1(x, y, msg_hash)
+        else:
+            mgf = self._mgfunc
+
+        modBits = Crypto.Util.number.size(self._key.n)
+
+        # See 8.1.1 in RFC3447
+        k = ceil_div(modBits, 8)  # k is length in bytes of the modulus
+        # Step 1
+        em = _EMSA_PSS_ENCODE(msg_hash, modBits-1, self._randfunc, mgf, sLen)
+        # Step 2a (OS2IP)
+        em_int = bytes_to_long(em)
+        # Step 2b (RSASP1) and Step 2c (I2OSP)
+        signature = self._key._decrypt_to_bytes(em_int)
+        # Verify no faults occurred
+        if em_int != pow(bytes_to_long(signature), self._key.e, self._key.n):
+            raise ValueError("Fault detected in RSA private key operation")
+        return signature
+
+    def verify(self, msg_hash, signature):
+        """Check if the  PKCS#1 PSS signature over a message is valid.
+
+        This function is also called ``RSASSA-PSS-VERIFY`` and
+        it is specified in
+        `section 8.1.2 of RFC8037 <https://tools.ietf.org/html/rfc8017#section-8.1.2>`_.
+
+        :parameter msg_hash:
+            The hash that was carried out over the message. This is an object
+            belonging to the :mod:`Crypto.Hash` module.
+        :type parameter: hash object
+
+        :parameter signature:
+            The signature that needs to be validated.
+        :type signature: bytes
+
+        :raise ValueError: if the signature is not valid.
+        """
+
+        # Set defaults for salt length and mask generation function
+        if self._saltLen is None:
+            sLen = msg_hash.digest_size
+        else:
+            sLen = self._saltLen
+        if self._mgfunc:
+            mgf = self._mgfunc
+        else:
+            mgf = lambda x, y: MGF1(x, y, msg_hash)
+
+        modBits = Crypto.Util.number.size(self._key.n)
+
+        # See 8.1.2 in RFC3447
+        k = ceil_div(modBits, 8)  # Convert from bits to bytes
+        # Step 1
+        if len(signature) != k:
+            raise ValueError("Incorrect signature")
+        # Step 2a (O2SIP)
+        signature_int = bytes_to_long(signature)
+        # Step 2b (RSAVP1)
+        em_int = self._key._encrypt(signature_int)
+        # Step 2c (I2OSP)
+        emLen = ceil_div(modBits - 1, 8)
+        em = long_to_bytes(em_int, emLen)
+        # Step 3/4
+        _EMSA_PSS_VERIFY(msg_hash, em, modBits-1, mgf, sLen)
+
+
+def MGF1(mgfSeed, maskLen, hash_gen):
+    """Mask Generation Function, described in `B.2.1 of RFC8017
+    <https://tools.ietf.org/html/rfc8017>`_.
+
+    :param mfgSeed:
+        seed from which the mask is generated
+    :type mfgSeed: byte string
+
+    :param maskLen:
+        intended length in bytes of the mask
+    :type maskLen: integer
+
+    :param hash_gen:
+        A module or a hash object from :mod:`Crypto.Hash`
+    :type hash_object:
+
+    :return: the mask, as a *byte string*
+    """
+
+    T = b""
+    for counter in iter_range(ceil_div(maskLen, hash_gen.digest_size)):
+        c = long_to_bytes(counter, 4)
+        hobj = hash_gen.new()
+        hobj.update(mgfSeed + c)
+        T = T + hobj.digest()
+    assert(len(T) >= maskLen)
+    return T[:maskLen]
+
+
+def _EMSA_PSS_ENCODE(mhash, emBits, randFunc, mgf, sLen):
+    r"""
+    Implement the ``EMSA-PSS-ENCODE`` function, as defined
+    in PKCS#1 v2.1 (RFC3447, 9.1.1).
+
+    The original ``EMSA-PSS-ENCODE`` actually accepts the message ``M``
+    as input, and hash it internally. Here, we expect that the message
+    has already been hashed instead.
+
+    :Parameters:
+      mhash : hash object
+        The hash object that holds the digest of the message being signed.
+      emBits : int
+        Maximum length of the final encoding, in bits.
+      randFunc : callable
+        An RNG function that accepts as only parameter an int, and returns
+        a string of random bytes, to be used as salt.
+      mgf : callable
+        A mask generation function that accepts two parameters: a string to
+        use as seed, and the lenth of the mask to generate, in bytes.
+      sLen : int
+        Length of the salt, in bytes.
+
+    :Return: An ``emLen`` byte long string that encodes the hash
+      (with ``emLen = \ceil(emBits/8)``).
+
+    :Raise ValueError:
+        When digest or salt length are too big.
+    """
+
+    emLen = ceil_div(emBits, 8)
+
+    # Bitmask of digits that fill up
+    lmask = 0
+    for i in iter_range(8*emLen-emBits):
+        lmask = lmask >> 1 | 0x80
+
+    # Step 1 and 2 have been already done
+    # Step 3
+    if emLen < mhash.digest_size+sLen+2:
+        raise ValueError("Digest or salt length are too long"
+                         " for given key size.")
+    # Step 4
+    salt = randFunc(sLen)
+    # Step 5
+    m_prime = bchr(0)*8 + mhash.digest() + salt
+    # Step 6
+    h = mhash.new()
+    h.update(m_prime)
+    # Step 7
+    ps = bchr(0)*(emLen-sLen-mhash.digest_size-2)
+    # Step 8
+    db = ps + bchr(1) + salt
+    # Step 9
+    dbMask = mgf(h.digest(), emLen-mhash.digest_size-1)
+    # Step 10
+    maskedDB = strxor(db, dbMask)
+    # Step 11
+    maskedDB = bchr(bord(maskedDB[0]) & ~lmask) + maskedDB[1:]
+    # Step 12
+    em = maskedDB + h.digest() + bchr(0xBC)
+    return em
+
+
+def _EMSA_PSS_VERIFY(mhash, em, emBits, mgf, sLen):
+    """
+    Implement the ``EMSA-PSS-VERIFY`` function, as defined
+    in PKCS#1 v2.1 (RFC3447, 9.1.2).
+
+    ``EMSA-PSS-VERIFY`` actually accepts the message ``M`` as input,
+    and hash it internally. Here, we expect that the message has already
+    been hashed instead.
+
+    :Parameters:
+      mhash : hash object
+        The hash object that holds the digest of the message to be verified.
+      em : string
+        The signature to verify, therefore proving that the sender really
+        signed the message that was received.
+      emBits : int
+        Length of the final encoding (em), in bits.
+      mgf : callable
+        A mask generation function that accepts two parameters: a string to
+        use as seed, and the lenth of the mask to generate, in bytes.
+      sLen : int
+        Length of the salt, in bytes.
+
+    :Raise ValueError:
+        When the encoding is inconsistent, or the digest or salt lengths
+        are too big.
+    """
+
+    emLen = ceil_div(emBits, 8)
+
+    # Bitmask of digits that fill up
+    lmask = 0
+    for i in iter_range(8*emLen-emBits):
+        lmask = lmask >> 1 | 0x80
+
+    # Step 1 and 2 have been already done
+    # Step 3
+    if emLen < mhash.digest_size+sLen+2:
+        raise ValueError("Incorrect signature")
+    # Step 4
+    if ord(em[-1:]) != 0xBC:
+        raise ValueError("Incorrect signature")
+    # Step 5
+    maskedDB = em[:emLen-mhash.digest_size-1]
+    h = em[emLen-mhash.digest_size-1:-1]
+    # Step 6
+    if lmask & bord(em[0]):
+        raise ValueError("Incorrect signature")
+    # Step 7
+    dbMask = mgf(h, emLen-mhash.digest_size-1)
+    # Step 8
+    db = strxor(maskedDB, dbMask)
+    # Step 9
+    db = bchr(bord(db[0]) & ~lmask) + db[1:]
+    # Step 10
+    if not db.startswith(bchr(0)*(emLen-mhash.digest_size-sLen-2) + bchr(1)):
+        raise ValueError("Incorrect signature")
+    # Step 11
+    if sLen > 0:
+        salt = db[-sLen:]
+    else:
+        salt = b""
+    # Step 12
+    m_prime = bchr(0)*8 + mhash.digest() + salt
+    # Step 13
+    hobj = mhash.new()
+    hobj.update(m_prime)
+    hp = hobj.digest()
+    # Step 14
+    if h != hp:
+        raise ValueError("Incorrect signature")
+
+
+def new(rsa_key, **kwargs):
+    """Create an object for making or verifying PKCS#1 PSS signatures.
+
+    :parameter rsa_key:
+      The RSA key to use for signing or verifying the message.
+      This is a :class:`Crypto.PublicKey.RSA` object.
+      Signing is only possible when ``rsa_key`` is a **private** RSA key.
+    :type rsa_key: RSA object
+
+    :Keyword Arguments:
+
+        *   *mask_func* (``callable``) --
+            A function that returns the mask (as `bytes`).
+            It must accept two parameters: a seed (as `bytes`)
+            and the length of the data to return.
+
+            If not specified, it will be the function :func:`MGF1` defined in
+            `RFC8017 <https://tools.ietf.org/html/rfc8017#page-67>`_ and
+            combined with the same hash algorithm applied to the
+            message to sign or verify.
+
+            If you want to use a different function, for instance still :func:`MGF1`
+            but together with another hash, you can do::
+
+                from Crypto.Hash import SHA256
+                from Crypto.Signature.pss import MGF1
+                mgf = lambda x, y: MGF1(x, y, SHA256)
+
+        *   *salt_bytes* (``integer``) --
+            Length of the salt, in bytes.
+            It is a value between 0 and ``emLen - hLen - 2``, where ``emLen``
+            is the size of the RSA modulus and ``hLen`` is the size of the digest
+            applied to the message to sign or verify.
+
+            The salt is generated internally, you don't need to provide it.
+
+            If not specified, the salt length will be ``hLen``.
+            If it is zero, the signature scheme becomes deterministic.
+
+            Note that in some implementations such as OpenSSL the default
+            salt length is ``emLen - hLen - 2`` (even though it is not more
+            secure than ``hLen``).
+
+        *   *rand_func* (``callable``) --
+            A function that returns random ``bytes``, of the desired length.
+            The default is :func:`Crypto.Random.get_random_bytes`.
+
+    :return: a :class:`PSS_SigScheme` signature object
+    """
+
+    mask_func = kwargs.pop("mask_func", None)
+    salt_len = kwargs.pop("salt_bytes", None)
+    rand_func = kwargs.pop("rand_func", None)
+    if rand_func is None:
+        rand_func = Random.get_random_bytes
+    if kwargs:
+        raise ValueError("Unknown keywords: " + str(kwargs.keys()))
+    return PSS_SigScheme(rsa_key, mask_func, salt_len, rand_func)

wemm/lib/python3.10/site-packages/_yaml/__init__.py

@@ -0,0 +1,33 @@
+# This is a stub package designed to roughly emulate the _yaml
+# extension module, which previously existed as a standalone module
+# and has been moved into the `yaml` package namespace.
+# It does not perfectly mimic its old counterpart, but should get
+# close enough for anyone who's relying on it even when they shouldn't.
+import yaml
+
+# in some circumstances, the yaml module we imoprted may be from a different version, so we need
+# to tread carefully when poking at it here (it may not have the attributes we expect)
+if not getattr(yaml, '__with_libyaml__', False):
+    from sys import version_info
+
+    exc = ModuleNotFoundError if version_info >= (3, 6) else ImportError
+    raise exc("No module named '_yaml'")
+else:
+    from yaml._yaml import *
+    import warnings
+    warnings.warn(
+        'The _yaml extension module is now located at yaml._yaml'
+        ' and its location is subject to change.  To use the'
+        ' LibYAML-based parser and emitter, import from `yaml`:'
+        ' `from yaml import CLoader as Loader, CDumper as Dumper`.',
+        DeprecationWarning
+    )
+    del warnings
+    # Don't `del yaml` here because yaml is actually an existing
+    # namespace member of _yaml.
+
+__name__ = '_yaml'
+# If the module is top-level (i.e. not a part of any specific package)
+# then the attribute should be set to ''.
+# https://docs.python.org/3.8/library/types.html
+__package__ = ''

wemm/lib/python3.10/site-packages/attrs-24.3.0.dist-info/METADATA

@@ -0,0 +1,246 @@
+Metadata-Version: 2.4
+Name: attrs
+Version: 24.3.0
+Summary: Classes Without Boilerplate
+Project-URL: Documentation, https://www.attrs.org/
+Project-URL: Changelog, https://www.attrs.org/en/stable/changelog.html
+Project-URL: GitHub, https://github.com/python-attrs/attrs
+Project-URL: Funding, https://github.com/sponsors/hynek
+Project-URL: Tidelift, https://tidelift.com/subscription/pkg/pypi-attrs?utm_source=pypi-attrs&utm_medium=pypi
+Author-email: Hynek Schlawack <hs@ox.cx>
+License-Expression: MIT
+License-File: LICENSE
+Keywords: attribute,boilerplate,class
+Classifier: Development Status :: 5 - Production/Stable
+Classifier: Programming Language :: Python :: 3.8
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Python :: Implementation :: CPython
+Classifier: Programming Language :: Python :: Implementation :: PyPy
+Classifier: Typing :: Typed
+Requires-Python: >=3.8
+Provides-Extra: benchmark
+Requires-Dist: cloudpickle; (platform_python_implementation == 'CPython') and extra == 'benchmark'
+Requires-Dist: hypothesis; extra == 'benchmark'
+Requires-Dist: mypy>=1.11.1; (platform_python_implementation == 'CPython' and python_version >= '3.10') and extra == 'benchmark'
+Requires-Dist: pympler; extra == 'benchmark'
+Requires-Dist: pytest-codspeed; extra == 'benchmark'
+Requires-Dist: pytest-mypy-plugins; (platform_python_implementation == 'CPython' and python_version >= '3.10') and extra == 'benchmark'
+Requires-Dist: pytest-xdist[psutil]; extra == 'benchmark'
+Requires-Dist: pytest>=4.3.0; extra == 'benchmark'
+Provides-Extra: cov
+Requires-Dist: cloudpickle; (platform_python_implementation == 'CPython') and extra == 'cov'
+Requires-Dist: coverage[toml]>=5.3; extra == 'cov'
+Requires-Dist: hypothesis; extra == 'cov'
+Requires-Dist: mypy>=1.11.1; (platform_python_implementation == 'CPython' and python_version >= '3.10') and extra == 'cov'
+Requires-Dist: pympler; extra == 'cov'
+Requires-Dist: pytest-mypy-plugins; (platform_python_implementation == 'CPython' and python_version >= '3.10') and extra == 'cov'
+Requires-Dist: pytest-xdist[psutil]; extra == 'cov'
+Requires-Dist: pytest>=4.3.0; extra == 'cov'
+Provides-Extra: dev
+Requires-Dist: cloudpickle; (platform_python_implementation == 'CPython') and extra == 'dev'
+Requires-Dist: hypothesis; extra == 'dev'
+Requires-Dist: mypy>=1.11.1; (platform_python_implementation == 'CPython' and python_version >= '3.10') and extra == 'dev'
+Requires-Dist: pre-commit-uv; extra == 'dev'
+Requires-Dist: pympler; extra == 'dev'
+Requires-Dist: pytest-mypy-plugins; (platform_python_implementation == 'CPython' and python_version >= '3.10') and extra == 'dev'
+Requires-Dist: pytest-xdist[psutil]; extra == 'dev'
+Requires-Dist: pytest>=4.3.0; extra == 'dev'
+Provides-Extra: docs
+Requires-Dist: cogapp; extra == 'docs'
+Requires-Dist: furo; extra == 'docs'
+Requires-Dist: myst-parser; extra == 'docs'
+Requires-Dist: sphinx; extra == 'docs'
+Requires-Dist: sphinx-notfound-page; extra == 'docs'
+Requires-Dist: sphinxcontrib-towncrier; extra == 'docs'
+Requires-Dist: towncrier<24.7; extra == 'docs'
+Provides-Extra: tests
+Requires-Dist: cloudpickle; (platform_python_implementation == 'CPython') and extra == 'tests'
+Requires-Dist: hypothesis; extra == 'tests'
+Requires-Dist: mypy>=1.11.1; (platform_python_implementation == 'CPython' and python_version >= '3.10') and extra == 'tests'
+Requires-Dist: pympler; extra == 'tests'
+Requires-Dist: pytest-mypy-plugins; (platform_python_implementation == 'CPython' and python_version >= '3.10') and extra == 'tests'
+Requires-Dist: pytest-xdist[psutil]; extra == 'tests'
+Requires-Dist: pytest>=4.3.0; extra == 'tests'
+Provides-Extra: tests-mypy
+Requires-Dist: mypy>=1.11.1; (platform_python_implementation == 'CPython' and python_version >= '3.10') and extra == 'tests-mypy'
+Requires-Dist: pytest-mypy-plugins; (platform_python_implementation == 'CPython' and python_version >= '3.10') and extra == 'tests-mypy'
+Description-Content-Type: text/markdown
+
+<p align="center">
+  <a href="https://www.attrs.org/">
+    <img src="https://raw.githubusercontent.com/python-attrs/attrs/main/docs/_static/attrs_logo.svg" width="35%" alt="attrs" />
+  </a>
+</p>
+
+
+*attrs* is the Python package that will bring back the **joy** of **writing classes** by relieving you from the drudgery of implementing object protocols (aka [dunder methods](https://www.attrs.org/en/latest/glossary.html#term-dunder-methods)).
+[Trusted by NASA](https://docs.github.com/en/account-and-profile/setting-up-and-managing-your-github-profile/customizing-your-profile/personalizing-your-profile#list-of-qualifying-repositories-for-mars-2020-helicopter-contributor-achievement) for Mars missions since 2020!
+
+Its main goal is to help you to write **concise** and **correct** software without slowing down your code.
+
+
+## Sponsors
+
+*attrs* would not be possible without our [amazing sponsors](https://github.com/sponsors/hynek).
+Especially those generously supporting us at the *The Organization* tier and higher:
+
+<!-- sponsor-break-begin -->
+
+<p align="center">
+
+<!-- [[[cog
+import pathlib, tomllib
+
+for sponsor in tomllib.loads(pathlib.Path("pyproject.toml").read_text())["tool"]["sponcon"]["sponsors"]:
+      print(f'<a href="{sponsor["url"]}"><img title="{sponsor["title"]}" src="https://www.attrs.org/en/24.3.0/_static/sponsors/{sponsor["img"]}" width="190" /></a>')
+]]] -->
+<a href="https://www.variomedia.de/"><img title="Variomedia AG" src="https://www.attrs.org/en/24.3.0/_static/sponsors/Variomedia.svg" width="190" /></a>
+<a href="https://tidelift.com/?utm_source=lifter&utm_medium=referral&utm_campaign=hynek"><img title="Tidelift" src="https://www.attrs.org/en/24.3.0/_static/sponsors/Tidelift.svg" width="190" /></a>
+<a href="https://klaviyo.com/"><img title="Klaviyo" src="https://www.attrs.org/en/24.3.0/_static/sponsors/Klaviyo.svg" width="190" /></a>
+<a href="https://www.emsys-renewables.com/"><img title="emsys renewables" src="https://www.attrs.org/en/24.3.0/_static/sponsors/emsys-renewables.svg" width="190" /></a>
+<a href="https://filepreviews.io/"><img title="FilePreviews" src="https://www.attrs.org/en/24.3.0/_static/sponsors/FilePreviews.svg" width="190" /></a>
+<a href="https://polar.sh/"><img title="Polar" src="https://www.attrs.org/en/24.3.0/_static/sponsors/Polar.svg" width="190" /></a>
+<!-- [[[end]]] -->
+
+</p>
+
+<!-- sponsor-break-end -->
+
+<p align="center">
+   <strong>Please consider <a href="https://github.com/sponsors/hynek">joining them</a> to help make <em>attrs</em>’s maintenance more sustainable!</strong>
+</p>
+
+<!-- teaser-end -->
+
+## Example
+
+*attrs* gives you a class decorator and a way to declaratively define the attributes on that class:
+
+<!-- code-begin -->
+
+```pycon
+>>> from attrs import asdict, define, make_class, Factory
+
+>>> @define
+... class SomeClass:
+...     a_number: int = 42
+...     list_of_numbers: list[int] = Factory(list)
+...
+...     def hard_math(self, another_number):
+...         return self.a_number + sum(self.list_of_numbers) * another_number
+
+
+>>> sc = SomeClass(1, [1, 2, 3])
+>>> sc
+SomeClass(a_number=1, list_of_numbers=[1, 2, 3])
+
+>>> sc.hard_math(3)
+19
+>>> sc == SomeClass(1, [1, 2, 3])
+True
+>>> sc != SomeClass(2, [3, 2, 1])
+True
+
+>>> asdict(sc)
+{'a_number': 1, 'list_of_numbers': [1, 2, 3]}
+
+>>> SomeClass()
+SomeClass(a_number=42, list_of_numbers=[])
+
+>>> C = make_class("C", ["a", "b"])
+>>> C("foo", "bar")
+C(a='foo', b='bar')
+```
+
+After *declaring* your attributes, *attrs* gives you:
+
+- a concise and explicit overview of the class's attributes,
+- a nice human-readable `__repr__`,
+- equality-checking methods,
+- an initializer,
+- and much more,
+
+*without* writing dull boilerplate code again and again and *without* runtime performance penalties.
+
+---
+
+This example uses *attrs*'s modern APIs that have been introduced in version 20.1.0, and the *attrs* package import name that has been added in version 21.3.0.
+The classic APIs (`@attr.s`, `attr.ib`, plus their serious-business aliases) and the `attr` package import name will remain **indefinitely**.
+
+Check out [*On The Core API Names*](https://www.attrs.org/en/latest/names.html) for an in-depth explanation!
+
+
+### Hate Type Annotations!?
+
+No problem!
+Types are entirely **optional** with *attrs*.
+Simply assign `attrs.field()` to the attributes instead of annotating them with types:
+
+```python
+from attrs import define, field
+
+@define
+class SomeClass:
+    a_number = field(default=42)
+    list_of_numbers = field(factory=list)
+```
+
+
+## Data Classes
+
+On the tin, *attrs* might remind you of `dataclasses` (and indeed, `dataclasses` [are a descendant](https://hynek.me/articles/import-attrs/) of *attrs*).
+In practice it does a lot more and is more flexible.
+For instance, it allows you to define [special handling of NumPy arrays for equality checks](https://www.attrs.org/en/stable/comparison.html#customization), allows more ways to [plug into the initialization process](https://www.attrs.org/en/stable/init.html#hooking-yourself-into-initialization), has a replacement for `__init_subclass__`, and allows for stepping through the generated methods using a debugger.
+
+For more details, please refer to our [comparison page](https://www.attrs.org/en/stable/why.html#data-classes), but generally speaking, we are more likely to commit crimes against nature to make things work that one would expect to work, but that are quite complicated in practice.
+
+
+## Project Information
+
+- [**Changelog**](https://www.attrs.org/en/stable/changelog.html)
+- [**Documentation**](https://www.attrs.org/)
+- [**PyPI**](https://pypi.org/project/attrs/)
+- [**Source Code**](https://github.com/python-attrs/attrs)
+- [**Contributing**](https://github.com/python-attrs/attrs/blob/main/.github/CONTRIBUTING.md)
+- [**Third-party Extensions**](https://github.com/python-attrs/attrs/wiki/Extensions-to-attrs)
+- **Get Help**: use the `python-attrs` tag on [Stack Overflow](https://stackoverflow.com/questions/tagged/python-attrs)
+
+
+### *attrs* for Enterprise
+
+Available as part of the [Tidelift Subscription](https://tidelift.com/?utm_source=lifter&utm_medium=referral&utm_campaign=hynek).
+
+The maintainers of *attrs* and thousands of other packages are working with Tidelift to deliver commercial support and maintenance for the open source packages you use to build your applications.
+Save time, reduce risk, and improve code health, while paying the maintainers of the exact packages you use.
+
+## Release Information
+
+### Backwards-incompatible Changes
+
+- Python 3.7 has been dropped.
+  [#1340](https://github.com/python-attrs/attrs/issues/1340)
+
+
+### Changes
+
+- Introduce `attrs.NothingType`, for annotating types consistent with `attrs.NOTHING`.
+  [#1358](https://github.com/python-attrs/attrs/issues/1358)
+- Allow mutating `__suppress_context__` and `__notes__` on frozen exceptions.
+  [#1365](https://github.com/python-attrs/attrs/issues/1365)
+- `attrs.converters.optional()` works again when taking `attrs.converters.pipe()` or another Converter as its argument.
+  [#1372](https://github.com/python-attrs/attrs/issues/1372)
+- *attrs* instances now support [`copy.replace()`](https://docs.python.org/3/library/copy.html#copy.replace).
+  [#1383](https://github.com/python-attrs/attrs/issues/1383)
+- `attrs.validators.instance_of()`'s type hints now allow for union types.
+  For example: `instance_of(str | int)`
+  [#1385](https://github.com/python-attrs/attrs/issues/1385)
+
+
+
+---
+
+[Full changelog →](https://www.attrs.org/en/stable/changelog.html)

wemm/lib/python3.10/site-packages/attrs-24.3.0.dist-info/RECORD

@@ -0,0 +1,56 @@
+attr/__init__.py,sha256=fOYIvt1eGSqQre4uCS3sJWKZ0mwAuC8UD6qba5OS9_U,2057
+attr/__init__.pyi,sha256=QIXnnHPoucmDWkbpNsWTP-cgJ1bn8le7DjyRa_wYdew,11281
+attr/__pycache__/__init__.cpython-310.pyc,,
+attr/__pycache__/_cmp.cpython-310.pyc,,
+attr/__pycache__/_compat.cpython-310.pyc,,
+attr/__pycache__/_config.cpython-310.pyc,,
+attr/__pycache__/_funcs.cpython-310.pyc,,
+attr/__pycache__/_make.cpython-310.pyc,,
+attr/__pycache__/_next_gen.cpython-310.pyc,,
+attr/__pycache__/_version_info.cpython-310.pyc,,
+attr/__pycache__/converters.cpython-310.pyc,,
+attr/__pycache__/exceptions.cpython-310.pyc,,
+attr/__pycache__/filters.cpython-310.pyc,,
+attr/__pycache__/setters.cpython-310.pyc,,
+attr/__pycache__/validators.cpython-310.pyc,,
+attr/_cmp.py,sha256=3umHiBtgsEYtvNP_8XrQwTCdFoZIX4DEur76N-2a3X8,4123
+attr/_cmp.pyi,sha256=U-_RU_UZOyPUEQzXE6RMYQQcjkZRY25wTH99sN0s7MM,368
+attr/_compat.py,sha256=4hlXbWhdDjQCDK6FKF1EgnZ3POiHgtpp54qE0nxaGHg,2704
+attr/_config.py,sha256=dGq3xR6fgZEF6UBt_L0T-eUHIB4i43kRmH0P28sJVw8,843
+attr/_funcs.py,sha256=5-tUKJtp3h5El55EcDl6GWXFp68fT8D8U7uCRN6497I,15854
+attr/_make.py,sha256=orKSf6C-B1eZfpat4lbAtxvmSyE_yxlG8zY9115ufWk,94157
+attr/_next_gen.py,sha256=7FRkbtl_N017SuBhf_Vw3mw2c2pGZhtCGOzadgz7tp4,24395
+attr/_typing_compat.pyi,sha256=XDP54TUn-ZKhD62TOQebmzrwFyomhUCoGRpclb6alRA,469
+attr/_version_info.py,sha256=exSqb3b5E-fMSsgZAlEw9XcLpEgobPORCZpcaEglAM4,2121
+attr/_version_info.pyi,sha256=x_M3L3WuB7r_ULXAWjx959udKQ4HLB8l-hsc1FDGNvk,209
+attr/converters.py,sha256=GlDeOzPeTFgeBBLbj9G57Ez5lAk68uhSALRYJ_exe84,3861
+attr/converters.pyi,sha256=orU2bff-VjQa2kMDyvnMQV73oJT2WRyQuw4ZR1ym1bE,643
+attr/exceptions.py,sha256=HRFq4iybmv7-DcZwyjl6M1euM2YeJVK_hFxuaBGAngI,1977
+attr/exceptions.pyi,sha256=zZq8bCUnKAy9mDtBEw42ZhPhAUIHoTKedDQInJD883M,539
+attr/filters.py,sha256=ZBiKWLp3R0LfCZsq7X11pn9WX8NslS2wXM4jsnLOGc8,1795
+attr/filters.pyi,sha256=3J5BG-dTxltBk1_-RuNRUHrv2qu1v8v4aDNAQ7_mifA,208
+attr/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+attr/setters.py,sha256=5-dcT63GQK35ONEzSgfXCkbB7pPkaR-qv15mm4PVSzQ,1617
+attr/setters.pyi,sha256=NnVkaFU1BB4JB8E4JuXyrzTUgvtMpj8p3wBdJY7uix4,584
+attr/validators.py,sha256=WaB1HLAHHqRHWsrv_K9H-sJ7ESil3H3Cmv2d8TtVZx4,20046
+attr/validators.pyi,sha256=s2WhKPqskxbsckJfKk8zOuuB088GfgpyxcCYSNFLqNU,2603
+attrs-24.3.0.dist-info/INSTALLER,sha256=zuuue4knoyJ-UwPPXg8fezS7VCrXJQrAP7zeNuwvFQg,4
+attrs-24.3.0.dist-info/METADATA,sha256=f9hhECeAUyS7iewHPRuMLDy1tpJ6vyy8R_TKUnCmiA8,11654
+attrs-24.3.0.dist-info/RECORD,,
+attrs-24.3.0.dist-info/REQUESTED,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+attrs-24.3.0.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+attrs-24.3.0.dist-info/licenses/LICENSE,sha256=iCEVyV38KvHutnFPjsbVy8q_Znyv-HKfQkINpj9xTp8,1109
+attrs/__init__.py,sha256=qeQJZ4O08yczSn840v9bYOaZyRE81WsVi-QCrY3krCU,1107
+attrs/__init__.pyi,sha256=nZmInocjM7tHV4AQw0vxO_fo6oJjL_PonlV9zKKW8DY,7931
+attrs/__pycache__/__init__.cpython-310.pyc,,
+attrs/__pycache__/converters.cpython-310.pyc,,
+attrs/__pycache__/exceptions.cpython-310.pyc,,
+attrs/__pycache__/filters.cpython-310.pyc,,
+attrs/__pycache__/setters.cpython-310.pyc,,
+attrs/__pycache__/validators.cpython-310.pyc,,
+attrs/converters.py,sha256=8kQljrVwfSTRu8INwEk8SI0eGrzmWftsT7rM0EqyohM,76
+attrs/exceptions.py,sha256=ACCCmg19-vDFaDPY9vFl199SPXCQMN_bENs4DALjzms,76
+attrs/filters.py,sha256=VOUMZug9uEU6dUuA0dF1jInUK0PL3fLgP0VBS5d-CDE,73
+attrs/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+attrs/setters.py,sha256=eL1YidYQV3T2h9_SYIZSZR1FAcHGb1TuCTy0E0Lv2SU,73
+attrs/validators.py,sha256=xcy6wD5TtTkdCG1f4XWbocPSO0faBjk5IfVJfP6SUj0,76

wemm/lib/python3.10/site-packages/attrs-24.3.0.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: hatchling 1.27.0
+Root-Is-Purelib: true
+Tag: py3-none-any

wemm/lib/python3.10/site-packages/botocore/data/amplifybackend/2020-08-11/endpoint-rule-set-1.json.gz

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:04e4c036ecdc99a04e567759ee2285cf996031c056457964a93e9ffd7a587ec4
+size 1127

wemm/lib/python3.10/site-packages/botocore/data/location/2020-11-19/endpoint-rule-set-1.json.gz

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:18f9e9138b3b2af3d284231b1664bf9d8a7f3a40a34760ce3e7ca9354197aca0
+size 1287

wemm/lib/python3.10/site-packages/tokenizers/__init__.py

@@ -0,0 +1,100 @@
+from enum import Enum
+from typing import List, Tuple, Union
+
+
+Offsets = Tuple[int, int]
+
+TextInputSequence = str
+"""A :obj:`str` that represents an input sequence """
+
+PreTokenizedInputSequence = Union[List[str], Tuple[str]]
+"""A pre-tokenized input sequence. Can be one of:
+
+    - A :obj:`List` of :obj:`str`
+    - A :obj:`Tuple` of :obj:`str`
+"""
+
+TextEncodeInput = Union[
+    TextInputSequence,
+    Tuple[TextInputSequence, TextInputSequence],
+    List[TextInputSequence],
+]
+"""Represents a textual input for encoding. Can be either:
+
+    - A single sequence: :data:`~tokenizers.TextInputSequence`
+    - A pair of sequences:
+
+      - A :obj:`Tuple` of :data:`~tokenizers.TextInputSequence`
+      - Or a :obj:`List` of :data:`~tokenizers.TextInputSequence` of size 2
+"""
+
+PreTokenizedEncodeInput = Union[
+    PreTokenizedInputSequence,
+    Tuple[PreTokenizedInputSequence, PreTokenizedInputSequence],
+    List[PreTokenizedInputSequence],
+]
+"""Represents a pre-tokenized input for encoding. Can be either:
+
+    - A single sequence: :data:`~tokenizers.PreTokenizedInputSequence`
+    - A pair of sequences:
+
+      - A :obj:`Tuple` of :data:`~tokenizers.PreTokenizedInputSequence`
+      - Or a :obj:`List` of :data:`~tokenizers.PreTokenizedInputSequence` of size 2
+"""
+
+InputSequence = Union[TextInputSequence, PreTokenizedInputSequence]
+"""Represents all the possible types of input sequences for encoding. Can be:
+
+    - When ``is_pretokenized=False``: :data:`~TextInputSequence`
+    - When ``is_pretokenized=True``: :data:`~PreTokenizedInputSequence`
+"""
+
+EncodeInput = Union[TextEncodeInput, PreTokenizedEncodeInput]
+"""Represents all the possible types of input for encoding. Can be:
+
+    - When ``is_pretokenized=False``: :data:`~TextEncodeInput`
+    - When ``is_pretokenized=True``: :data:`~PreTokenizedEncodeInput`
+"""
+
+
+class OffsetReferential(Enum):
+    ORIGINAL = "original"
+    NORMALIZED = "normalized"
+
+
+class OffsetType(Enum):
+    BYTE = "byte"
+    CHAR = "char"
+
+
+class SplitDelimiterBehavior(Enum):
+    REMOVED = "removed"
+    ISOLATED = "isolated"
+    MERGED_WITH_PREVIOUS = "merged_with_previous"
+    MERGED_WITH_NEXT = "merged_with_next"
+    CONTIGUOUS = "contiguous"
+
+
+from .tokenizers import (
+    AddedToken,
+    Encoding,
+    NormalizedString,
+    PreTokenizedString,
+    Regex,
+    Token,
+    Tokenizer,
+    decoders,
+    models,
+    normalizers,
+    pre_tokenizers,
+    processors,
+    trainers,
+    __version__,
+)
+from .implementations import (
+    BertWordPieceTokenizer,
+    ByteLevelBPETokenizer,
+    CharBPETokenizer,
+    SentencePieceBPETokenizer,
+    SentencePieceUnigramTokenizer,
+)

wemm/lib/python3.10/site-packages/tokenizers/decoders/__init__.py

@@ -0,0 +1,14 @@
+from .. import decoders
+
+
+Decoder = decoders.Decoder
+ByteLevel = decoders.ByteLevel
+Replace = decoders.Replace
+WordPiece = decoders.WordPiece
+ByteFallback = decoders.ByteFallback
+Fuse = decoders.Fuse
+Strip = decoders.Strip
+Metaspace = decoders.Metaspace
+BPEDecoder = decoders.BPEDecoder
+CTC = decoders.CTC
+Sequence = decoders.Sequence

wemm/lib/python3.10/site-packages/tokenizers/implementations/__init__.py

@@ -0,0 +1,6 @@
+from .base_tokenizer import BaseTokenizer
+from .bert_wordpiece import BertWordPieceTokenizer
+from .byte_level_bpe import ByteLevelBPETokenizer
+from .char_level_bpe import CharBPETokenizer
+from .sentencepiece_bpe import SentencePieceBPETokenizer
+from .sentencepiece_unigram import SentencePieceUnigramTokenizer