aboutsummaryrefslogtreecommitdiff
path: root/frozen_deps/Cryptodome/Util
diff options
context:
space:
mode:
Diffstat (limited to 'frozen_deps/Cryptodome/Util')
-rw-r--r--frozen_deps/Cryptodome/Util/Counter.py7
-rw-r--r--frozen_deps/Cryptodome/Util/Padding.py2
-rwxr-xr-xfrozen_deps/Cryptodome/Util/_cpuid_c.abi3.sobin0 -> 12776 bytes
-rw-r--r--frozen_deps/Cryptodome/Util/_raw_api.py62
-rwxr-xr-xfrozen_deps/Cryptodome/Util/_strxor.abi3.sobin0 -> 14960 bytes
-rw-r--r--frozen_deps/Cryptodome/Util/asn1.py19
-rw-r--r--frozen_deps/Cryptodome/Util/number.py101
-rw-r--r--frozen_deps/Cryptodome/Util/py3compat.py34
-rw-r--r--frozen_deps/Cryptodome/Util/py3compat.pyi12
-rw-r--r--frozen_deps/Cryptodome/Util/strxor.py51
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
Binary files differ
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
Binary files differ
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)))
-
Powered by cgit, Themed by Ted Yin.