v0.1.7

10 files changed, 168 insertions, 120 deletions

diff --git a/frozen_deps/Cryptodome/Util/Counter.py b/frozen_deps/Cryptodome/Util/Counter.py
index 423f91f..c67bc95 100644
--- a/frozen_deps/Cryptodome/Util/Counter.py
+++ b/frozen_deps/Cryptodome/Util/Counter.py
@@ -45,6 +45,7 @@ def new(nbits, prefix=b"", suffix=b"", initial_value=1, little_endian=False, all
         used.
       initial_value (integer):
         The initial value of the counter. Default value is 1.
+        Its length in bits must not exceed the argument ``nbits``.
       little_endian (boolean):
         If ``True``, the counter number will be encoded in little endian format.
         If ``False`` (default), in big endian format.
@@ -61,6 +62,12 @@ def new(nbits, prefix=b"", suffix=b"", initial_value=1, little_endian=False, all
     if (nbits % 8) != 0:
         raise ValueError("'nbits' must be a multiple of 8")
 
+    iv_bl = initial_value.bit_length()
+    if iv_bl > nbits:
+        raise ValueError("Initial value takes %d bits but it is longer than "
+                         "the counter (%d bits)" %
+                         (iv_bl, nbits))
+
     # Ignore wraparound
     return {"counter_len": nbits // 8,
             "prefix": prefix,
diff --git a/frozen_deps/Cryptodome/Util/Padding.py b/frozen_deps/Cryptodome/Util/Padding.py
index 1c353d1..b525475 100644
--- a/frozen_deps/Cryptodome/Util/Padding.py
+++ b/frozen_deps/Cryptodome/Util/Padding.py
@@ -82,6 +82,8 @@ def unpad(padded_data, block_size, style='pkcs7'):
     """
 
     pdata_len = len(padded_data)
+    if pdata_len == 0:
+        raise ValueError("Zero-length input cannot be unpadded")
     if pdata_len % block_size:
         raise ValueError("Input data is not padded")
     if style in ('pkcs7', 'x923'):
diff --git a/frozen_deps/Cryptodome/Util/_cpuid_c.abi3.so b/frozen_deps/Cryptodome/Util/_cpuid_c.abi3.so
new file mode 100755
index 0000000..60f1e26
--- /dev/null
+++ b/frozen_deps/Cryptodome/Util/_cpuid_c.abi3.so
diff --git a/frozen_deps/Cryptodome/Util/_raw_api.py b/frozen_deps/Cryptodome/Util/_raw_api.py
index 9423738..c2e0187 100644
--- a/frozen_deps/Cryptodome/Util/_raw_api.py
+++ b/frozen_deps/Cryptodome/Util/_raw_api.py
@@ -28,6 +28,7 @@
 # POSSIBILITY OF SUCH DAMAGE.
 # ===================================================================
 
+import os
 import abc
 import sys
 from Cryptodome.Util.py3compat import byte_string
@@ -50,10 +51,7 @@ else:
     extension_suffixes = machinery.EXTENSION_SUFFIXES
 
 # Which types with buffer interface we support (apart from byte strings)
-if sys.version_info[0] == 2 and sys.version_info[1] < 7:
-    _buffer_type = (bytearray)
-else:
-    _buffer_type = (bytearray, memoryview)
+_buffer_type = (bytearray, memoryview)
 
 
 class _VoidPointer(object):
@@ -69,9 +67,6 @@ class _VoidPointer(object):
 
 
 try:
-    if sys.version_info[0] == 2 and sys.version_info[1] < 7:
-        raise ImportError("CFFI is only supported with Python 2.7+")
-
     # Starting from v2.18, pycparser (used by cffi for in-line ABI mode)
     # stops working correctly when PYOPTIMIZE==2 or the parameter -OO is
     # passed. In that case, we fall back to ctypes.
@@ -98,7 +93,10 @@ try:
         @cdecl, the C function declarations.
         """
 
-        lib = ffi.dlopen(name)
+        if hasattr(ffi, "RTLD_DEEPBIND") and not os.getenv('PYCRYPTODOME_DISABLE_DEEPBIND'):
+            lib = ffi.dlopen(name, ffi.RTLD_DEEPBIND)
+        else:
+            lib = ffi.dlopen(name)
         ffi.cdef(cdecl)
         return lib
 
@@ -108,6 +106,7 @@ try:
 
     c_ulonglong = c_ulong
     c_uint = c_ulong
+    c_ubyte = c_ulong
 
     def c_size_t(x):
         """Convert a Python integer to size_t"""
@@ -171,6 +170,11 @@ except ImportError:
     null_pointer = None
     cached_architecture = []
 
+    def c_ubyte(c):
+        if not (0 <= c < 256):
+            raise OverflowError()
+        return ctypes.c_ubyte(c)
+
     def load_lib(name, cdecl):
         if not cached_architecture:
             # platform.architecture() creates a subprocess, so caching the
@@ -193,12 +197,7 @@ except ImportError:
 
     # ---- Get raw pointer ---
 
-    if sys.version_info[0] == 2 and sys.version_info[1] == 6:
-        # ctypes in 2.6 does not define c_ssize_t. Replacing it
-        # with c_size_t keeps the structure correctely laid out
-        _c_ssize_t = c_size_t
-    else:
-        _c_ssize_t = ctypes.c_ssize_t
+    _c_ssize_t = ctypes.c_ssize_t
 
     _PyBUF_SIMPLE = 0
     _PyObject_GetBuffer = ctypes.pythonapi.PyObject_GetBuffer
@@ -207,7 +206,7 @@ except ImportError:
     _c_ssize_p = ctypes.POINTER(_c_ssize_t)
 
     # See Include/object.h for CPython
-    # and https://github.com/pallets/click/blob/master/click/_winconsole.py
+    # and https://github.com/pallets/click/blob/master/src/click/_winconsole.py
     class _Py_buffer(ctypes.Structure):
         _fields_ = [
             ('buf',         c_void_p),
@@ -235,7 +234,7 @@ except ImportError:
             buf = _Py_buffer()
             _PyObject_GetBuffer(obj, byref(buf), _PyBUF_SIMPLE)
             try:
-                buffer_type = c_ubyte * buf.len
+                buffer_type = ctypes.c_ubyte * buf.len
                 return buffer_type.from_address(buf.buf)
             finally:
                 _PyBuffer_Release(byref(buf))
@@ -260,7 +259,6 @@ except ImportError:
         return VoidPointer_ctypes()
 
     backend = "ctypes"
-    del ctypes
 
 
 class SmartPointer(object):
@@ -301,27 +299,21 @@ def load_pycryptodome_raw_lib(name, cdecl):
     for ext in extension_suffixes:
         try:
             filename = basename + ext
-            return load_lib(pycryptodome_filename(dir_comps, filename),
-                            cdecl)
+            full_name = pycryptodome_filename(dir_comps, filename)
+            if not os.path.isfile(full_name):
+                attempts.append("Not found '%s'" % filename)
+                continue
+            return load_lib(full_name, cdecl)
         except OSError as exp:
-            attempts.append("Trying '%s': %s" % (filename, str(exp)))
+            attempts.append("Cannot load '%s': %s" % (filename, str(exp)))
     raise OSError("Cannot load native module '%s': %s" % (name, ", ".join(attempts)))
 
 
-if sys.version_info[:2] != (2, 6):
-    
-    def is_buffer(x):
-        """Return True if object x supports the buffer interface"""
-        return isinstance(x, (bytes, bytearray, memoryview))
-
-    def is_writeable_buffer(x):
-        return (isinstance(x, bytearray) or
-                (isinstance(x, memoryview) and not x.readonly))
-
-else:
+def is_buffer(x):
+    """Return True if object x supports the buffer interface"""
+    return isinstance(x, (bytes, bytearray, memoryview))
 
-    def is_buffer(x):
-        return isinstance(x, (bytes, bytearray))
 
-    def is_writeable_buffer(x):
-        return isinstance(x, bytearray)
+def is_writeable_buffer(x):
+    return (isinstance(x, bytearray) or
+            (isinstance(x, memoryview) and not x.readonly))
diff --git a/frozen_deps/Cryptodome/Util/_strxor.abi3.so b/frozen_deps/Cryptodome/Util/_strxor.abi3.so
new file mode 100755
index 0000000..c028978
--- /dev/null
+++ b/frozen_deps/Cryptodome/Util/_strxor.abi3.so
diff --git a/frozen_deps/Cryptodome/Util/asn1.py b/frozen_deps/Cryptodome/Util/asn1.py
index 18e080c..a88f087 100644
--- a/frozen_deps/Cryptodome/Util/asn1.py
+++ b/frozen_deps/Cryptodome/Util/asn1.py
@@ -137,7 +137,7 @@ class DerObject(object):
                     self._tag_octet = 0xA0 | self._convertTag(explicit)
                     self._inner_tag_octet = 0x20 * constructed | asn1Id
                     return
-                
+
                 self._tag_octet = 0x20 * constructed | asn1Id
 
         def _convertTag(self, tag):
@@ -442,7 +442,7 @@ class DerSequence(DerObject):
                   only_non_negative (boolean):
                     If ``True``, negative integers are not counted in.
                 """
-                
+
                 items = [x for x in self._seq if _is_number(x, only_non_negative)]
                 return len(items)
 
@@ -704,21 +704,20 @@ class DerBitString(DerObject):
     An example of encoding is:
 
     >>> from Cryptodome.Util.asn1 import DerBitString
-    >>> from binascii import hexlify, unhexlify
-    >>> bs_der = DerBitString(b'\\xaa')
-    >>> bs_der.value += b'\\xbb'
-    >>> print hexlify(bs_der.encode())
+    >>> bs_der = DerBitString(b'\\xAA')
+    >>> bs_der.value += b'\\xBB'
+    >>> print(bs_der.encode().hex())
 
-    which will show ``040300aabb``, the DER encoding for the bit string
+    which will show ``030300aabb``, the DER encoding for the bit string
     ``b'\\xAA\\xBB'``.
 
     For decoding:
 
-    >>> s = unhexlify(b'040300aabb')
+    >>> s = bytes.fromhex('030300aabb')
     >>> try:
     >>>   bs_der = DerBitString()
     >>>   bs_der.decode(s)
-    >>>   print hexlify(bs_der.value)
+    >>>   print(bs_der.value.hex())
     >>> except ValueError:
     >>>   print "Not a valid DER BIT STRING"
 
@@ -751,7 +750,7 @@ class DerBitString(DerObject):
 
     def encode(self):
         """Return the DER BIT STRING, fully encoded as a
-        binary string."""
+        byte string."""
 
         # Add padding count byte
         self.payload = b'\x00' + self.value
diff --git a/frozen_deps/Cryptodome/Util/number.py b/frozen_deps/Cryptodome/Util/number.py
index 0367fdc..5af85a3 100644
--- a/frozen_deps/Cryptodome/Util/number.py
+++ b/frozen_deps/Cryptodome/Util/number.py
@@ -28,7 +28,7 @@ import math
 import sys
 import struct
 from Cryptodome import Random
-from Cryptodome.Util.py3compat import _memoryview, iter_range
+from Cryptodome.Util.py3compat import iter_range
 
 # Backward compatibility
 _fastmath = None
@@ -141,14 +141,19 @@ def inverse(u, v):
 def getPrime(N, randfunc=None):
     """Return a random N-bit prime number.
 
+    N must be an integer larger than 1.
     If randfunc is omitted, then :meth:`Random.get_random_bytes` is used.
     """
     if randfunc is None:
         randfunc = Random.get_random_bytes
 
-    number=getRandomNBitInteger(N, randfunc) | 1
-    while (not isPrime(number, randfunc=randfunc)):
-        number=number+2
+    if N < 2:
+        raise ValueError("N must be larger than 1")
+
+    while True:
+        number = getRandomNBitInteger(N, randfunc) | 1
+        if isPrime(number, randfunc=randfunc):
+            break
     return number
 
 
@@ -375,46 +380,72 @@ def isPrime(N, false_positive_prob=1e-6, randfunc=None):
 import struct
 
 def long_to_bytes(n, blocksize=0):
-    """Convert an integer to a byte string.
+    """Convert a positive integer to a byte string using big endian encoding.
 
-    In Python 3.2+, use the native method instead::
+    If :data:`blocksize` is absent or zero, the byte string will
+    be of minimal length.
 
-        >>> n.to_bytes(blocksize, 'big')
+    Otherwise, the length of the byte string is guaranteed to be a multiple
+    of :data:`blocksize`. If necessary, zeroes (``\\x00``) are added at the left.
 
-    For instance::
+    .. note::
+        In Python 3, if you are sure that :data:`n` can fit into
+        :data:`blocksize` bytes, you can simply use the native method instead::
 
-        >>> n = 80
-        >>> n.to_bytes(2, 'big')
-        b'\x00P'
+            >>> n.to_bytes(blocksize, 'big')
 
-    If the optional :data:`blocksize` is provided and greater than zero,
-    the byte string is padded with binary zeros (on the front) so that
-    the total length of the output is a multiple of blocksize.
+        For instance::
 
-    If :data:`blocksize` is zero or not provided, the byte string will
-    be of minimal length.
+            >>> n = 80
+            >>> n.to_bytes(2, 'big')
+            b'\\x00P'
+
+        However, and unlike this ``long_to_bytes()`` function,
+        an ``OverflowError`` exception is raised if :data:`n` does not fit.
     """
-    # after much testing, this algorithm was deemed to be the fastest
-    s = b''
-    n = int(n)
+
+    if n < 0 or blocksize < 0:
+        raise ValueError("Values must be non-negative")
+
+    result = []
     pack = struct.pack
-    while n > 0:
-        s = pack('>I', n & 0xffffffff) + s
+
+    # Fill the first block independently from the value of n
+    bsr = blocksize
+    while bsr >= 8:
+        result.insert(0, pack('>Q', n & 0xFFFFFFFFFFFFFFFF))
+        n = n >> 64
+        bsr -= 8
+
+    while bsr >= 4:
+        result.insert(0, pack('>I', n & 0xFFFFFFFF))
         n = n >> 32
-    # strip off leading zeros
-    for i in range(len(s)):
-        if s[i] != b'\x00'[0]:
-            break
+        bsr -= 4
+
+    while bsr > 0:
+        result.insert(0, pack('>B', n & 0xFF))
+        n = n >> 8
+        bsr -= 1
+
+    if n == 0:
+        if len(result) == 0:
+            bresult = b'\x00'
+        else:
+            bresult = b''.join(result)
     else:
-        # only happens when n == 0
-        s = b'\x00'
-        i = 0
-    s = s[i:]
-    # add back some pad bytes.  this could be done more efficiently w.r.t. the
-    # de-padding being done above, but sigh...
-    if blocksize > 0 and len(s) % blocksize:
-        s = (blocksize - len(s) % blocksize) * b'\x00' + s
-    return s
+        # The encoded number exceeds the block size
+        while n > 0:
+            result.insert(0, pack('>Q', n & 0xFFFFFFFFFFFFFFFF))
+            n = n >> 64
+        result[0] = result[0].lstrip(b'\x00')
+        bresult = b''.join(result)
+        # bresult has minimum length here
+        if blocksize > 0:
+            target_len = ((len(bresult) - 1) // blocksize + 1) * blocksize
+            bresult = b'\x00' * (target_len - len(bresult)) + bresult
+
+    return bresult
+
 
 def bytes_to_long(s):
     """Convert a byte string to a long integer (big endian).
@@ -439,7 +470,7 @@ def bytes_to_long(s):
     if sys.version_info[0:3] < (2, 7, 4):
         if isinstance(s, bytearray):
             s = bytes(s)
-        elif isinstance(s, _memoryview):
+        elif isinstance(s, memoryview):
             s = s.tobytes()
 
     length = len(s)
diff --git a/frozen_deps/Cryptodome/Util/py3compat.py b/frozen_deps/Cryptodome/Util/py3compat.py
index 40ef752..9a982e9 100644
--- a/frozen_deps/Cryptodome/Util/py3compat.py
+++ b/frozen_deps/Cryptodome/Util/py3compat.py
@@ -78,6 +78,8 @@ if sys.version_info[0] == 2:
             return s
         elif isinstance(s, bytearray):
             return bytes(s)
+        elif isinstance(s, memoryview):
+            return s.tobytes()
         else:
             return ''.join(s)
     def tostr(bs):
@@ -85,17 +87,11 @@ if sys.version_info[0] == 2:
     def byte_string(s):
         return isinstance(s, str)
 
-    # In Pyton 2.x, StringIO is a stand-alone module
-    from StringIO import StringIO as BytesIO
+    from StringIO import StringIO
+    BytesIO = StringIO
 
     from sys import maxint
 
-    if sys.version_info[1] < 7:
-        import types
-        _memoryview = types.NoneType
-    else:
-        _memoryview = memoryview
-    
     iter_range = xrange
 
     def is_native_int(x):
@@ -104,8 +100,15 @@ if sys.version_info[0] == 2:
     def is_string(x):
         return isinstance(x, basestring)
 
+    def is_bytes(x):
+        return isinstance(x, str) or \
+                isinstance(x, bytearray) or \
+                isinstance(x, memoryview)
+
     ABC = abc.ABCMeta('ABC', (object,), {'__slots__': ()})
 
+    FileNotFoundError = IOError
+
 else:
     def b(s):
        return s.encode("latin-1") # utf-8 would cause some side-effects we don't want
@@ -125,6 +128,8 @@ else:
             return bytes(s)
         elif isinstance(s,str):
             return s.encode(encoding)
+        elif isinstance(s, memoryview):
+            return s.tobytes()
         else:
             return bytes([s])
     def tostr(bs):
@@ -132,12 +137,10 @@ else:
     def byte_string(s):
         return isinstance(s, bytes)
 
-    # In Python 3.x, StringIO is a sub-module of io
     from io import BytesIO
+    from io import StringIO
     from sys import maxsize as maxint
 
-    _memoryview = memoryview
-
     iter_range = range
 
     def is_native_int(x):
@@ -146,14 +149,21 @@ else:
     def is_string(x):
         return isinstance(x, str)
 
+    def is_bytes(x):
+        return isinstance(x, bytes) or \
+                isinstance(x, bytearray) or \
+                isinstance(x, memoryview)
+
     from abc import ABC
 
+    FileNotFoundError = FileNotFoundError
+
 
 def _copy_bytes(start, end, seq):
     """Return an immutable copy of a sequence (byte string, byte array, memoryview)
     in a certain interval [start:seq]"""
 
-    if isinstance(seq, _memoryview):
+    if isinstance(seq, memoryview):
         return seq[start:end].tobytes()
     elif isinstance(seq, bytearray):
         return bytes(seq[start:end])
diff --git a/frozen_deps/Cryptodome/Util/py3compat.pyi b/frozen_deps/Cryptodome/Util/py3compat.pyi
index 3297dc0..74e04a2 100644
--- a/frozen_deps/Cryptodome/Util/py3compat.pyi
+++ b/frozen_deps/Cryptodome/Util/py3compat.pyi
@@ -13,23 +13,21 @@ def bytestring(x: Any) -> bool: ...
 
 def is_native_int(s: Any) -> bool: ...
 def is_string(x: Any) -> bool: ...
+def is_bytes(x: Any) -> bool: ...
 
 def BytesIO(b: bytes) -> IO[bytes]: ...
+def StringIO(s: str) -> IO[str]: ...
 
 if sys.version_info[0] == 2:
     from sys import maxint
     iter_range = xrange
 
-    if sys.version_info[1] < 7:
-        import types
-        _memoryview = types.NoneType
-    else:
-        _memoryview = memoryview
-
 else:
     from sys import maxsize as maxint
     iter_range = range
 
-    _memoryview = memoryview
+class FileNotFoundError:
+    def __init__(self, err: int, msg: str, filename: str) -> None:
+        pass
 
 def _copy_bytes(start: Optional[int], end: Optional[int], seq: Buffer) -> bytes: ...
diff --git a/frozen_deps/Cryptodome/Util/strxor.py b/frozen_deps/Cryptodome/Util/strxor.py
index 91fb4c9..6b16155 100644
--- a/frozen_deps/Cryptodome/Util/strxor.py
+++ b/frozen_deps/Cryptodome/Util/strxor.py
@@ -32,7 +32,8 @@ from Cryptodome.Util._raw_api import (load_pycryptodome_raw_lib, c_size_t,
                                   create_string_buffer, get_raw_buffer,
                                   c_uint8_ptr, is_writeable_buffer)
 
-_raw_strxor = load_pycryptodome_raw_lib("Cryptodome.Util._strxor",
+_raw_strxor = load_pycryptodome_raw_lib(
+                    "Cryptodome.Util._strxor",
                     """
                     void strxor(const uint8_t *in1,
                                 const uint8_t *in2,
@@ -45,33 +46,38 @@ _raw_strxor = load_pycryptodome_raw_lib("Cryptodome.Util._strxor",
 
 
 def strxor(term1, term2, output=None):
-    """XOR two byte strings.
-    
+    """From two byte strings of equal length,
+    create a third one which is the byte-by-byte XOR of the two.
+
     Args:
       term1 (bytes/bytearray/memoryview):
-        The first term of the XOR operation.
+        The first byte string to XOR.
       term2 (bytes/bytearray/memoryview):
-        The second term of the XOR operation.
+        The second byte string to XOR.
       output (bytearray/memoryview):
-        The location where the result must be written to.
+        The location where the result will be written to.
+        It must have the same length as ``term1`` and ``term2``.
         If ``None``, the result is returned.
     :Return:
-        If ``output`` is ``None``, a new ``bytes`` string with the result.
+        If ``output`` is ``None``, a new byte string with the result.
         Otherwise ``None``.
+
+    .. note::
+        ``term1`` and ``term2`` must have the same length.
     """
 
     if len(term1) != len(term2):
         raise ValueError("Only byte strings of equal length can be xored")
-    
+
     if output is None:
         result = create_string_buffer(len(term1))
     else:
         # Note: output may overlap with either input
         result = output
-        
+
         if not is_writeable_buffer(output):
             raise TypeError("output must be a bytearray or a writeable memoryview")
-        
+
         if len(term1) != len(output):
             raise ValueError("output must have the same length as the input"
                              "  (%d bytes)" % len(term1))
@@ -88,15 +94,19 @@ def strxor(term1, term2, output=None):
 
 
 def strxor_c(term, c, output=None):
-    """XOR a byte string with a repeated sequence of characters.
+    """From a byte string, create a second one of equal length
+    where each byte is XOR-red with the same value.
 
     Args:
-        term(bytes/bytearray/memoryview):
-            The first term of the XOR operation.
-        c (bytes):
-            The byte that makes up the second term of the XOR operation.
-        output (None or bytearray/memoryview):
-            If not ``None``, the location where the result is stored into.
+      term(bytes/bytearray/memoryview):
+        The byte string to XOR.
+      c (int):
+        Every byte in the string will be XOR-ed with this value.
+        It must be between 0 and 255 (included).
+      output (None or bytearray/memoryview):
+        The location where the result will be written to.
+        It must have the same length as ``term``.
+        If ``None``, the result is returned.
 
     Return:
         If ``output`` is ``None``, a new ``bytes`` string with the result.
@@ -105,16 +115,16 @@ def strxor_c(term, c, output=None):
 
     if not 0 <= c < 256:
         raise ValueError("c must be in range(256)")
-    
+
     if output is None:
         result = create_string_buffer(len(term))
     else:
         # Note: output may overlap with either input
         result = output
-       
+
         if not is_writeable_buffer(output):
             raise TypeError("output must be a bytearray or a writeable memoryview")
-        
+
         if len(term) != len(output):
             raise ValueError("output must have the same length as the input"
                              "  (%d bytes)" % len(term))
@@ -134,4 +144,3 @@ def strxor_c(term, c, output=None):
 def _strxor_direct(term1, term2, result):
     """Very fast XOR - check conditions!"""
     _raw_strxor.strxor(term1, term2, result, c_size_t(len(term1)))
-