4263290326

Build Type

github

Committed by GitHub

Commit Message

Merge 651661ace into 644412d7a

Pull Request Pull Request #313: Ci updates

Run Details

2143 of 2183 branches covered (98.17%)

Branch coverage included in aggregate %.

14 of 17 new or added lines in 5 files covered. (82.35%)

8 existing lines in 1 file now uncovered.

5943 of 6014 relevant lines covered (98.82%)

19.25 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

91.74

/src/ecdsa/_compat.py

"""
Common functions for providing cross-python version compatibility.
"""
import sys
import re
import binascii
from six import integer_types


def str_idx_as_int(string, index):
    """Take index'th byte from string, return as integer"""
    val = string[index]
    if isinstance(val, integer_types):
        return val
    return ord(val)


if sys.version_info < (3, 0):  # pragma: no branch
    import platform

    def normalise_bytes(buffer_object):
        """Cast the input into array of bytes."""
        # flake8 runs on py3 where `buffer` indeed doesn't exist...
        return buffer(buffer_object)  # noqa: F821

    def hmac_compat(ret):
        return ret

    if (
        sys.version_info < (2, 7)
        or sys.version_info < (2, 7, 4)
        or platform.system() == "Java"
    ):  # pragma: no branch

        def remove_whitespace(text):
            """Removes all whitespace from passed in string"""
            return re.sub(r"\s+", "", text)

        def compat26_str(val):
            return str(val)

        def bit_length(val):
            if val == 0:
                return 0
            return len(bin(val)) - 2

    else:

        def remove_whitespace(text):
            """Removes all whitespace from passed in string"""
            return re.sub(r"\s+", "", text, flags=re.UNICODE)

        def compat26_str(val):
            return val

        def bit_length(val):
            """Return number of bits necessary to represent an integer."""
            return val.bit_length()

    def b2a_hex(val):
        return binascii.b2a_hex(compat26_str(val))

    def a2b_hex(val):
        try:
            return bytearray(binascii.a2b_hex(val))
        except Exception as e:
            raise ValueError("base16 error: %s" % e)

    def bytes_to_int(val, byteorder):
        """Convert bytes to an int."""
        if not val:
            return 0
        if byteorder == "big":
            return int(b2a_hex(val), 16)
        if byteorder == "little":
            return int(b2a_hex(val[::-1]), 16)
        raise ValueError("Only 'big' and 'little' endian supported")

    def int_to_bytes(val, length=None, byteorder="big"):
        """Return number converted to bytes"""
        if length is None:
            length = byte_length(val)
        if byteorder == "big":
            return bytearray(
                (val >> i) & 0xFF for i in reversed(range(0, length * 8, 8))
            )
        if byteorder == "little":
            return bytearray(
                (val >> i) & 0xFF for i in range(0, length * 8, 8)
            )
        raise ValueError("Only 'big' or 'little' endian supported")

else:
    if sys.version_info < (3, 4):  # pragma: no branch
        # on python 3.3 hmac.hmac.update() accepts only bytes, on newer
        # versions it does accept memoryview() also
        def hmac_compat(data):
            if not isinstance(data, bytes):  # pragma: no branch
                return bytes(data)
            return data

        def normalise_bytes(buffer_object):
            """Cast the input into array of bytes."""
            if not buffer_object:
                return b""
            return memoryview(buffer_object).cast("B")

    else:

        def hmac_compat(data):
            return data

        def normalise_bytes(buffer_object):
            """Cast the input into array of bytes."""
            return memoryview(buffer_object).cast("B")

    def compat26_str(val):
        return val

    def remove_whitespace(text):
        """Removes all whitespace from passed in string"""
        return re.sub(r"\s+", "", text, flags=re.UNICODE)

    def a2b_hex(val):
        try:
            return bytearray(binascii.a2b_hex(bytearray(val, "ascii")))
        except Exception as e:
            raise ValueError("base16 error: %s" % e)

    # pylint: disable=invalid-name
    # pylint is stupid here and doesn't notice it's a function, not
    # constant
    bytes_to_int = int.from_bytes
    # pylint: enable=invalid-name

    def bit_length(val):
        """Return number of bits necessary to represent an integer."""
        return val.bit_length()

    def int_to_bytes(val, length=None, byteorder="big"):
        """Convert integer to bytes."""
        if length is None:
            length = byte_length(val)
        # for gmpy we need to convert back to native int
        if type(val) != int:
            val = int(val)
        return bytearray(val.to_bytes(length=length, byteorder=byteorder))


def byte_length(val):
    """Return number of bytes necessary to represent an integer."""
    length = bit_length(val)
    return (length + 7) // 8

1	"""
2	Common functions for providing cross-python version compatibility.
3	"""
4	import sys	20✔
5	import re	20✔
6	import binascii	20✔
7	from six import integer_types	20✔
8
9
10	def str_idx_as_int(string, index):	20✔
11	"""Take index'th byte from string, return as integer"""
12	val = string[index]	20✔
13	if isinstance(val, integer_types):	20✔
14	return val	20✔
15	return ord(val)	20✔
16
17
18	if sys.version_info < (3, 0): # pragma: no branch	20✔
19	import platform	8✔
20
21	def normalise_bytes(buffer_object):	8✔
22	"""Cast the input into array of bytes."""
23	# flake8 runs on py3 where `buffer` indeed doesn't exist...
24	return buffer(buffer_object) # noqa: F821	8✔
25
26	def hmac_compat(ret):	8✔
27	return ret	8✔
28
29	if (	8✔
30	sys.version_info < (2, 7)
31	or sys.version_info < (2, 7, 4)
32	or platform.system() == "Java"
33	): # pragma: no branch
34
35	def remove_whitespace(text):	1✔
36	"""Removes all whitespace from passed in string"""
37	return re.sub(r"\s+", "", text)	1✔
38
39	def compat26_str(val):	1✔
40	return str(val)	1✔
41
42	def bit_length(val):	1✔
43	if val == 0:	1✔
44	return 0	1✔
45	return len(bin(val)) - 2	1✔
46
47	else:
48
49	def remove_whitespace(text):	7✔
50	"""Removes all whitespace from passed in string"""
51	return re.sub(r"\s+", "", text, flags=re.UNICODE)	7✔
52
53	def compat26_str(val):	7✔
54	return val	7✔
55
56	def bit_length(val):	7✔
57	"""Return number of bits necessary to represent an integer."""
58	return val.bit_length()	7✔
59
60	def b2a_hex(val):	8✔
61	return binascii.b2a_hex(compat26_str(val))	8✔
62
63	def a2b_hex(val):	8✔
64	try:	8✔
65	return bytearray(binascii.a2b_hex(val))	8✔
66	except Exception as e:	8✔
67	raise ValueError("base16 error: %s" % e)	8✔
68
69	def bytes_to_int(val, byteorder):	8✔
70	"""Convert bytes to an int."""
71	if not val:	8✔
72	return 0	8✔
73	if byteorder == "big":	8✔
74	return int(b2a_hex(val), 16)	8✔
75	if byteorder == "little":	8✔
76	return int(b2a_hex(val[::-1]), 16)	8✔
77	raise ValueError("Only 'big' and 'little' endian supported")	8✔
78
79	def int_to_bytes(val, length=None, byteorder="big"):	8✔
80	"""Return number converted to bytes"""
81	if length is None:	8✔
82	length = byte_length(val)	8✔
83	if byteorder == "big":	8✔
84	return bytearray(	8✔
85	(val >> i) & 0xFF for i in reversed(range(0, length * 8, 8))
86	)
87	if byteorder == "little":	8✔
88	return bytearray(	8✔
89	(val >> i) & 0xFF for i in range(0, length * 8, 8)
90	)
91	raise ValueError("Only 'big' or 'little' endian supported")	8✔
92
93	else:
94	if sys.version_info < (3, 4): # pragma: no branch	12✔
95	# on python 3.3 hmac.hmac.update() accepts only bytes, on newer
96	# versions it does accept memoryview() also
UNCOV 97	def hmac_compat(data):	×
NEW UNCOV 98	if not isinstance(data, bytes): # pragma: no branch	×
NEW UNCOV 99	return bytes(data)	×
NEW UNCOV 100	return data	×
101
UNCOV 102	def normalise_bytes(buffer_object):	×
103	"""Cast the input into array of bytes."""
UNCOV 104	if not buffer_object:	×
UNCOV 105	return b""	×
UNCOV 106	return memoryview(buffer_object).cast("B")	×
107
108	else:
109
110	def hmac_compat(data):	12✔
111	return data	12✔
112
113	def normalise_bytes(buffer_object):	12✔
114	"""Cast the input into array of bytes."""
115	return memoryview(buffer_object).cast("B")	12✔
116
117	def compat26_str(val):	12✔
118	return val	12✔
119
120	def remove_whitespace(text):	12✔
121	"""Removes all whitespace from passed in string"""
122	return re.sub(r"\s+", "", text, flags=re.UNICODE)	12✔
123
124	def a2b_hex(val):	12✔
125	try:	12✔
126	return bytearray(binascii.a2b_hex(bytearray(val, "ascii")))	12✔
127	except Exception as e:	12✔
128	raise ValueError("base16 error: %s" % e)	12✔
129
130	# pylint: disable=invalid-name
131	# pylint is stupid here and doesn't notice it's a function, not
132	# constant
133	bytes_to_int = int.from_bytes	12✔
134	# pylint: enable=invalid-name
135
136	def bit_length(val):	12✔
137	"""Return number of bits necessary to represent an integer."""
138	return val.bit_length()	12✔
139
140	def int_to_bytes(val, length=None, byteorder="big"):	12✔
141	"""Convert integer to bytes."""
142	if length is None:	12✔
143	length = byte_length(val)	12✔
144	# for gmpy we need to convert back to native int
145	if type(val) != int:	12✔
146	val = int(val)	2✔
147	return bytearray(val.to_bytes(length=length, byteorder=byteorder))	12✔
148
149
150	def byte_length(val):	20✔
151	"""Return number of bytes necessary to represent an integer."""
152	length = bit_length(val)	20✔
153	return (length + 7) // 8	20✔

tlsfuzzer / python-ecdsa / 4263290326

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous