2c08a340dd6e0556a03b02dbd505cfffd5babc3a-PR-2067

Build # 2c08a340dd6e0556a03b02dbd505cfffd5babc3a-PR-2067

Build Type

Pull #2067

github-actions

Committed by GitHub

Commit Message

<a href="https://github.com/Gallopsled/pwntools/commit/<a class=hub.com/Gallopsled/pwntools/commit/<a class="double-link" href="https://git"><a class=hub.com/Gallopsled/pwntools/commit/<a class="double-link" href="https://git"><a class=hub.com/Gallopsled/pwntools/commit/2c08a340dd6e0556a03b02dbd505cfffd5babc3a">2c08a340d">&lt;a href=&quot;https://github.com/Gallopsled/pwntools/commit/</a><a class="double-link" href="https://github.com/Gallopsled/pwntools/commit/&lt;a class=&quot;double-link&quot; href=&quot;https://git">&lt;a class=</a>hub.com/Gallopsled/pwntools/commit/&lt;a class=&quot;double-link&quot; href=&quot;https://git">&lt;a class=</a>hub.com/Gallopsled/pwntools/commit/&lt;a class=&quot;double-link&quot; href=&quot;https://git">&lt;a class=</a>hub.com/Gallopsled/pwntools/commit/&lt;a class=&quot;double-link&quot; href=&quot;https://git">&lt;a class=</a>hub.com/Gallopsled/pwntools/commit/&lt;a class=&quot;double-link&quot; href=&quot;https://git">&lt;a class=</a>hub.com/Gallopsled/pwntools/commit/2c08a340dd6e0556a03b02dbd505cfffd5babc3a">2c08a340d</a><a href="https://github.com/Gallopsled/pwntools/commit/2c08a340dd6e0556a03b02dbd505cfffd5babc3a">&quot;&gt;&amp;lt;a href=&amp;quot;https://github.com/Gallopsled/pwntools/commit/&lt;/a&gt;&lt;a class=&quot;double-link&quot; href=&quot;https://github.com/Gallopsled/pwntools/commit/&amp;lt;a class=&amp;quot;double-link&amp;quot; href=&amp;quot;https://git&quot;&gt;&amp;lt;a class=&lt;/a&gt;hub.com/Gallopsled/pwntools/commit/&amp;lt;a class=&amp;quot;double-link&amp;quot; href=&amp;quot;https://git&quot;&gt;&amp;lt;a class=&lt;/a&gt;hub.com/Gallopsled/pwntools/commit/&amp;lt;a class=&amp;quot;double-link&amp;quot; href=&amp;quot;https://git&quot;&gt;&amp;lt;a class=&lt;/a&gt;hub.com/Gallopsled/pwntools/commit/&amp;lt;a class=&amp;quot;double-link&amp;quot; href=&amp;quot;https://git&quot;&gt;&amp;lt;a class=&lt;/a&gt;hub.com/Gallopsled/pwntools/commit/&amp;lt;a class=&amp;quot;double-link&amp;quot; href=&amp;quot;https://git&quot;&gt;&amp;lt;a class=&lt;/a&gt;hub.com/Gallopsled/pwntools/commit/2c08a340dd6e0556a03b02dbd505cfffd5babc3a&quot;&gt;2c08a340d&lt;/a&gt;&lt;a href=&quot;https://github.com/Gallopsled/pwntools/commi... (continued)

Pull Request Pull Request #2067: Fix crc.

Run Details

3555 of 6320 branches covered (56.25%)

3 of 3 new or added lines in 1 file covered. (100.0%)

11547 of 16510 relevant lines covered (69.94%)

0.7 hits per line

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

86.5

/pwnlib/util/crc/__init__.py

from __future__ import absolute_import
from __future__ import division

import six
import sys
import types

from pwnlib.util import fiddling
from pwnlib.util import packing
from pwnlib.util import safeeval
from pwnlib.util.crc import known

class Nothing:
    """Module for calculating CRC-sums.

    Contains all crc implementations know on the interwebz. For most implementations
    it contains only the core crc algorithm and not e.g. padding schemes.

    It is horribly slow, as implements a naive algorithm working direclty on
    bit polynomials. This class is exposed as `BitPolynom`.

    The current algorithm is super-linear and takes about 4 seconds to calculate
    the crc32-sum of ``'A'*40000``.

    An obvious optimization would be to actually generate some lookup-tables.

    This doctest is to ensure that the known data are accurate:
        >>> known = sys.modules['pwnlib.util.crc.known']
        >>> known.all_crcs == known.generate()
        True
    """
    pass


class BitPolynom(object):
    """Class for representing GF(2)[X], i.e. the field of polynomials over
    GF(2).

    In practice the polynomials are represented as numbers such that `x**n`
    corresponds to `1 << n`. In this representation calculations are easy: Just
    do everything as normal, but forget about everything the carries.

    Addition becomes xor and multiplication becomes carry-less multiplication.

    Examples:

        >>> p1 = BitPolynom("x**3 + x + 1")
        >>> p1
        BitPolynom('x**3 + x + 1')
        >>> int(p1)
        11
        >>> p1 == BitPolynom(11)
        True
        >>> p2 = BitPolynom("x**2 + x + 1")
        >>> p1 + p2
        BitPolynom('x**3 + x**2')
        >>> p1 * p2
        BitPolynom('x**5 + x**4 + 1')
        >>> p1 // p2
        BitPolynom('x + 1')
        >>> p1 % p2
        BitPolynom('x')
        >>> d, r = divmod(p1, p2)
        >>> d * p2 + r == p1
        True
        >>> BitPolynom(-1)
        Traceback (most recent call last):
            ...
        ValueError: Polynomials cannot be negative: -1
        >>> BitPolynom('y')
        Traceback (most recent call last):
            ...
        ValueError: Not a valid polynomial: y
    """


    def __init__(self, n):
        if isinstance(n, (bytes, six.text_type)):
            self.n = 0
            x = BitPolynom(2)
            try:
                for p in n.split('+'):
                    k = safeeval.values(p.strip(), {'x': x, 'X': x})
                    assert isinstance(k, (BitPolynom,)+six.integer_types)
                    k = int(k)
                    assert k >= 0
                    self.n ^= k
            except (ValueError, NameError, AssertionError):
                raise ValueError("Not a valid polynomial: %s" % n)
        elif isinstance(n, six.integer_types):
            if n >= 0:
                self.n = n
            else:
                raise ValueError("Polynomials cannot be negative: %d" % n)
        else:
            raise TypeError("Polynomial must be called with a string or integer")

    def __int__(self):
        return self.n

    def __add__(self, other):
        return BitPolynom(int(self) ^ int(other))

    def __radd__(self, other):
        return BitPolynom(int(self) ^ int(other))

    def __sub__(self, other):
        return BitPolynom(int(self) ^ int(other))

    def __rsub__(self, other):
        return BitPolynom(int(self) ^ int(other))

    def __xor__(self, other):
        return BitPolynom(int(self) ^ int(other))

    def __rxor__(self, other):
        return BitPolynom(int(self) ^ int(other))

    def __or__(self, other):
        return BitPolynom(int(self) | int(other))

    def __ror__(self, other):
        return BitPolynom(int(self) | int(other))

    def __and__(self, other):
        return BitPolynom(int(self) & int(other))

    def __rand__(self, other):
        return BitPolynom(int(self) & int(other))

    def __mul__(self, other):
        a, b = int(self), int(other)
        if a > b:
            a, b = b, a

        res = 0
        for n in range(a.bit_length()):
            if a & (1 << n):
                res ^= b << n
        return BitPolynom(res)

    def __rmul__(self, other):
        return self * other

    def __divmod__(self, other):
        other = BitPolynom(int(other))

        if other == 0:
            raise ZeroDivisionError

        resd = 0
        resm = int(self)

        for n in range(self.degree() - other.degree(), -1, -1):
            if resm & (1 << (n + other.degree())):
                resm ^= int(other) << n
                resd ^= 1 << n
        return (BitPolynom(resd), BitPolynom(resm))

    def __rdivmod__(self, other):
        return divmod(BitPolynom(int(other)), self)

    def __div__(self, other):
        return divmod(self, other)[0]
    __floordiv__ = __div__

    def __rdiv__(self, other):
        return divmod(other, self)[0]
    __rfloordiv__ = __rdiv__

    __floordiv__ = __div__
    __rfloordiv__ = __rdiv__

    def __mod__(self, other):
        return divmod(self, other)[1]

    def __rmod__(self, other):
        return divmod(other, self)[1]

    def __eq__(self, other):
        return int(self) == int(other)

    def __hash__(self):
        return int(self).__hash__()

    def __cmp__(self, other):
        return int(self).__lt__(int(other))

    def __lshift__(self, other):
        return BitPolynom(int(self) << int(other))

    def __rlshift__(self, other):
        return BitPolynom(int(other) << int(self))

    def __rshift__(self, other):
        return BitPolynom(int(self) >> int(other))

    def __rrshift__(self, other):
        return BitPolynom(int(other) >> int(self))

    def __pow__(self, other):
        r = BitPolynom(1)
        for _ in range(other):
            r *= self
        return r

    def degree(self):
        """Returns the degree of the polynomial.

        Examples:

            >>> BitPolynom(0).degree()
            0
            >>> BitPolynom(1).degree()
            0
            >>> BitPolynom(2).degree()
            1
            >>> BitPolynom(7).degree()
            2
            >>> BitPolynom((1 << 10) - 1).degree()
            9
            >>> BitPolynom(1 << 10).degree()
            10
        """
        return max(0, int(self).bit_length()-1)

    def __repr__(self):
        if int(self) == 0:
            return '0'

        out = []
        for n in range(self.degree(), 1, -1):
            if int(self) & (1 << n):
                out.append("x**%d" % n)
        if int(self) & 2:
            out.append("x")
        if int(self) & 1:
            out.append("1")
        return 'BitPolynom(%r)' % ' + '.join(out)

class Module(types.ModuleType):
    def __init__(self):
        super(Module, self).__init__(__name__)
        self._cached_crcs = None
        self.BitPolynom = BitPolynom
        self.__dict__.update({
            '__file__'    : __file__,
            '__package__' : __package__,
        })

    def __getattr__(self, attr):
        crcs = known.all_crcs

        if attr == '__all__':
            return ['BitPolynom', 'generic_crc', 'cksum', 'find_crc_function'] + sorted(crcs.keys())

        info = crcs.get(attr, None)
        if not info:
            raise AttributeError("'module' object has no attribute %r" % attr)

        func = self._make_crc(info['name'], info['poly'], info['width'], info['init'], info['refin'], info['refout'], info['xorout'], info['check'], 'See also: ' + info['link'])

        setattr(self, attr, func)

        return func

    def __dir__(self):
        return self.__all__

    @staticmethod
    def generic_crc(data, polynom, width, init, refin, refout, xorout):
        """A generic CRC-sum function.

        This is suitable to use with:
        https://reveng.sourceforge.io/crc-catalogue/all.htm

        The "check" value in the document is the CRC-sum of the string "123456789".

        Arguments:
            data(str):    The data to calculate the CRC-sum of. This should either be a string or a list of bits.
            polynom(int): The polynomial to use.
            init(int):    If the CRC-sum was calculated in hardware, then this would b
                        the initial value of the checksum register.
            refin(bool):  Should the input bytes be reflected?
            refout(bool): Should the checksum be reflected?
            xorout(int):  The value to xor the checksum with before outputting
        """

        polynom = BitPolynom(int(polynom)) | (1 << width)
        if polynom.degree() != width:
            raise ValueError("Polynomial is too large for that width")

        init   &= (1 << width)-1
        xorout &= (1 << width)-1

        if isinstance(data, list):
            # refin is not meaningful in this case
            inlen = len(data)
            p = BitPolynom(int(''.join('1' if v else '0' for v in data), 2))
        elif isinstance(data, six.binary_type):
            inlen = len(data)*8
            if refin:
                data = fiddling.bitswap(data)
            p = BitPolynom(packing.unpack(data, 'all', endian='big', sign=False))
        else:
            raise ValueError("Don't know how to crc %s()" % type(data).__name__)
        p = p << width
        p ^= init << inlen
        p  = p % polynom
        res = p.n
        if refout:
            res = fiddling.bitswap_int(res, width)
        res ^= xorout

        return res

    @staticmethod
    def _make_crc(name, polynom, width, init, refin, refout, xorout, check, extra_doc = ''):
        def inner(data):
            return crc.generic_crc(data, polynom, width, init, refin, refout, xorout)
        inner.func_name = 'crc_' + name
        inner.__name__  = 'crc_' + name
        inner.__qualname__  = 'crc_' + name

        inner.__doc__   = """%s(data) -> int

        Calculates the %s checksum.

        This is simply the :func:`generic_crc` with these frozen arguments:

        * polynom = 0x%x
        * width   = %d
        * init    = 0x%x
        * refin   = %s
        * refout  = %s
        * xorout  = 0x%x

        %s

        Arguments:
            data(str): The data to checksum.

        Example:
            >>> print(%s(b'123456789'))
            %d
    """ % (name, name, polynom, width, init, refin, refout, xorout, extra_doc, name, check)

        return inner

    @staticmethod
    def cksum(data):
        """cksum(data) -> int

        Calculates the same checksum as returned by the UNIX-tool ``cksum``.

        Arguments:
            data(str): The data to checksum.

        Example:
            >>> print(cksum(b'123456789'))
            930766865
        """

        l = len(data)
        data += packing.pack(l, 'all', endian='little', sign=False)
        return crc.crc_32_posix(data)

    @staticmethod
    def find_crc_function(data, checksum):
        """Finds all known CRC functions that hashes a piece of data into a specific
        checksum. It does this by trying all known CRC functions one after the other.

        Arguments:
            data(str): Data for which the checksum is known.

        Example:
            >>> find_crc_function(b'test', 46197)
            [<function crc_crc_16_dnp at ...>]
        """
        candidates = []
        for v in known.all_crcs.keys():
            func = getattr(crc, v)
            if func(data) == checksum:
                candidates.append(func)
        return candidates


tether = sys.modules[__name__]
crc = sys.modules[__name__] = Module()
crc.__doc__ = tether.__doc__

1	from __future__ import absolute_import	1✔
2	from __future__ import division	1✔
3
4	import six	1✔
5	import sys	1✔
6	import types	1✔
7
8	from pwnlib.util import fiddling	1✔
9	from pwnlib.util import packing	1✔
10	from pwnlib.util import safeeval	1✔
11	from pwnlib.util.crc import known	1✔
12
13	class Nothing:	1✔
14	"""Module for calculating CRC-sums.
15
16	Contains all crc implementations know on the interwebz. For most implementations
17	it contains only the core crc algorithm and not e.g. padding schemes.
18
19	It is horribly slow, as implements a naive algorithm working direclty on
20	bit polynomials. This class is exposed as `BitPolynom`.
21
22	The current algorithm is super-linear and takes about 4 seconds to calculate
23	the crc32-sum of ``'A'*40000``.
24
25	An obvious optimization would be to actually generate some lookup-tables.
26
27	This doctest is to ensure that the known data are accurate:
28	>>> known = sys.modules['pwnlib.util.crc.known']
29	>>> known.all_crcs == known.generate()
30	True
31	"""
32	pass	1✔
33
34
35	class BitPolynom(object):	1✔
36	"""Class for representing GF(2)[X], i.e. the field of polynomials over
37	GF(2).
38
39	In practice the polynomials are represented as numbers such that `x**n`
40	corresponds to `1 << n`. In this representation calculations are easy: Just
41	do everything as normal, but forget about everything the carries.
42
43	Addition becomes xor and multiplication becomes carry-less multiplication.
44
45	Examples:
46
47	>>> p1 = BitPolynom("x**3 + x + 1")
48	>>> p1
49	BitPolynom('x**3 + x + 1')
50	>>> int(p1)
51	11
52	>>> p1 == BitPolynom(11)
53	True
54	>>> p2 = BitPolynom("x**2 + x + 1")
55	>>> p1 + p2
56	BitPolynom('x3 + x2')
57	>>> p1 * p2
58	BitPolynom('x5 + x4 + 1')
59	>>> p1 // p2
60	BitPolynom('x + 1')
61	>>> p1 % p2
62	BitPolynom('x')
63	>>> d, r = divmod(p1, p2)
64	>>> d * p2 + r == p1
65	True
66	>>> BitPolynom(-1)
67	Traceback (most recent call last):
68	...
69	ValueError: Polynomials cannot be negative: -1
70	>>> BitPolynom('y')
71	Traceback (most recent call last):
72	...
73	ValueError: Not a valid polynomial: y
74	"""
75
76
77	def __init__(self, n):	1✔
78	if isinstance(n, (bytes, six.text_type)):	1✔
79	self.n = 0	1✔
80	x = BitPolynom(2)	1✔
81	try:	1✔
82	for p in n.split('+'):	1✔
83	k = safeeval.values(p.strip(), {'x': x, 'X': x})	1✔
84	assert isinstance(k, (BitPolynom,)+six.integer_types)	1✔
85	k = int(k)	1✔
86	assert k >= 0	1✔
87	self.n ^= k	1✔
88	except (ValueError, NameError, AssertionError):	1✔
89	raise ValueError("Not a valid polynomial: %s" % n)	1✔
90	elif isinstance(n, six.integer_types):	1!
91	if n >= 0:	1✔
92	self.n = n	1✔
93	else:
94	raise ValueError("Polynomials cannot be negative: %d" % n)	1✔
95	else:
96	raise TypeError("Polynomial must be called with a string or integer")	×
97
98	def __int__(self):	1✔
99	return self.n	1✔
100
101	def __add__(self, other):	1✔
102	return BitPolynom(int(self) ^ int(other))	1✔
103
104	def __radd__(self, other):	1✔
105	return BitPolynom(int(self) ^ int(other))	×
106
107	def __sub__(self, other):	1✔
108	return BitPolynom(int(self) ^ int(other))	×
109
110	def __rsub__(self, other):	1✔
111	return BitPolynom(int(self) ^ int(other))	×
112
113	def __xor__(self, other):	1✔
114	return BitPolynom(int(self) ^ int(other))	1✔
115
116	def __rxor__(self, other):	1✔
117	return BitPolynom(int(self) ^ int(other))	×
118
119	def __or__(self, other):	1✔
120	return BitPolynom(int(self) \| int(other))	1✔
121
122	def __ror__(self, other):	1✔
123	return BitPolynom(int(self) \| int(other))	×
124
125	def __and__(self, other):	1✔
126	return BitPolynom(int(self) & int(other))	×
127
128	def __rand__(self, other):	1✔
129	return BitPolynom(int(self) & int(other))	×
130
131	def __mul__(self, other):	1✔
132	a, b = int(self), int(other)	1✔
133	if a > b:	1✔
134	a, b = b, a	1✔
135
136	res = 0	1✔
137	for n in range(a.bit_length()):	1✔
138	if a & (1 << n):	1✔
139	res ^= b << n	1✔
140	return BitPolynom(res)	1✔
141
142	def __rmul__(self, other):	1✔
143	return self * other	×
144
145	def __divmod__(self, other):	1✔
146	other = BitPolynom(int(other))	1✔
147
148	if other == 0:	1!
149	raise ZeroDivisionError	×
150
151	resd = 0	1✔
152	resm = int(self)	1✔
153
154	for n in range(self.degree() - other.degree(), -1, -1):	1✔
155	if resm & (1 << (n + other.degree())):	1✔
156	resm ^= int(other) << n	1✔
157	resd ^= 1 << n	1✔
158	return (BitPolynom(resd), BitPolynom(resm))	1✔
159
160	def __rdivmod__(self, other):	1✔
161	return divmod(BitPolynom(int(other)), self)	×
162
163	def __div__(self, other):	1✔
164	return divmod(self, other)[0]	1✔
165	__floordiv__ = __div__	1✔
166
167	def __rdiv__(self, other):	1✔
168	return divmod(other, self)[0]	×
169	__rfloordiv__ = __rdiv__	1✔
170
171	__floordiv__ = __div__	1✔
172	__rfloordiv__ = __rdiv__	1✔
173
174	def __mod__(self, other):	1✔
175	return divmod(self, other)[1]	1✔
176
177	def __rmod__(self, other):	1✔
178	return divmod(other, self)[1]	×
179
180	def __eq__(self, other):	1✔
181	return int(self) == int(other)	1✔
182
183	def __hash__(self):	1✔
184	return int(self).__hash__()	×
185
186	def __cmp__(self, other):	1✔
187	return int(self).__lt__(int(other))	×
188
189	def __lshift__(self, other):	1✔
190	return BitPolynom(int(self) << int(other))	1✔
191
192	def __rlshift__(self, other):	1✔
193	return BitPolynom(int(other) << int(self))	×
194
195	def __rshift__(self, other):	1✔
196	return BitPolynom(int(self) >> int(other))	×
197
198	def __rrshift__(self, other):	1✔
199	return BitPolynom(int(other) >> int(self))	×
200
201	def __pow__(self, other):	1✔
202	r = BitPolynom(1)	1✔
203	for _ in range(other):	1✔
204	r *= self	1✔
205	return r	1✔
206
207	def degree(self):	1✔
208	"""Returns the degree of the polynomial.
209
210	Examples:
211
212	>>> BitPolynom(0).degree()
213	0
214	>>> BitPolynom(1).degree()
215	0
216	>>> BitPolynom(2).degree()
217	1
218	>>> BitPolynom(7).degree()
219	2
220	>>> BitPolynom((1 << 10) - 1).degree()
221	9
222	>>> BitPolynom(1 << 10).degree()
223	10
224	"""
225	return max(0, int(self).bit_length()-1)	1✔
226
227	def __repr__(self):	1✔
228	if int(self) == 0:	1!
229	return '0'	×
230
231	out = []	1✔
232	for n in range(self.degree(), 1, -1):	1✔
233	if int(self) & (1 << n):	1✔
234	out.append("x**%d" % n)	1✔
235	if int(self) & 2:	1✔
236	out.append("x")	1✔
237	if int(self) & 1:	1✔
238	out.append("1")	1✔
239	return 'BitPolynom(%r)' % ' + '.join(out)	1✔
240
241	class Module(types.ModuleType):	1✔
242	def __init__(self):	1✔
243	super(Module, self).__init__(__name__)	1✔
244	self._cached_crcs = None	1✔
245	self.BitPolynom = BitPolynom	1✔
246	self.__dict__.update({	1✔
247	'__file__' : __file__,
248	'__package__' : __package__,
249	})
250
251	def __getattr__(self, attr):	1✔
252	crcs = known.all_crcs	1✔
253
254	if attr == '__all__':	1✔
255	return ['BitPolynom', 'generic_crc', 'cksum', 'find_crc_function'] + sorted(crcs.keys())	1✔
256
257	info = crcs.get(attr, None)	1✔
258	if not info:	1✔
259	raise AttributeError("'module' object has no attribute %r" % attr)	1✔
260
261	func = self._make_crc(info['name'], info['poly'], info['width'], info['init'], info['refin'], info['refout'], info['xorout'], info['check'], 'See also: ' + info['link'])	1✔
262
263	setattr(self, attr, func)	1✔
264
265	return func	1✔
266
267	def __dir__(self):	1✔
268	return self.__all__	×
269
270	@staticmethod	1✔
271	def generic_crc(data, polynom, width, init, refin, refout, xorout):
272	"""A generic CRC-sum function.
273
274	This is suitable to use with:
275	https://reveng.sourceforge.io/crc-catalogue/all.htm
276
277	The "check" value in the document is the CRC-sum of the string "123456789".
278
279	Arguments:
280	data(str): The data to calculate the CRC-sum of. This should either be a string or a list of bits.
281	polynom(int): The polynomial to use.
282	init(int): If the CRC-sum was calculated in hardware, then this would b
283	the initial value of the checksum register.
284	refin(bool): Should the input bytes be reflected?
285	refout(bool): Should the checksum be reflected?
286	xorout(int): The value to xor the checksum with before outputting
287	"""
288
289	polynom = BitPolynom(int(polynom)) \| (1 << width)	1✔
290	if polynom.degree() != width:	1!
291	raise ValueError("Polynomial is too large for that width")	×
292
293	init &= (1 << width)-1	1✔
294	xorout &= (1 << width)-1	1✔
295
296	if isinstance(data, list):	1!
297	# refin is not meaningful in this case
298	inlen = len(data)	×
299	p = BitPolynom(int(''.join('1' if v else '0' for v in data), 2))	×
300	elif isinstance(data, six.binary_type):	1!
301	inlen = len(data)*8	1✔
302	if refin:	1✔
303	data = fiddling.bitswap(data)	1✔
304	p = BitPolynom(packing.unpack(data, 'all', endian='big', sign=False))	1✔
305	else:
306	raise ValueError("Don't know how to crc %s()" % type(data).__name__)	×
307	p = p << width	1✔
308	p ^= init << inlen	1✔
309	p = p % polynom	1✔
310	res = p.n	1✔
311	if refout:	1✔
312	res = fiddling.bitswap_int(res, width)	1✔
313	res ^= xorout	1✔
314
315	return res	1✔
316
317	@staticmethod	1✔
318	def _make_crc(name, polynom, width, init, refin, refout, xorout, check, extra_doc = ''):	1✔
319	def inner(data):	1✔
320	return crc.generic_crc(data, polynom, width, init, refin, refout, xorout)	1✔
321	inner.func_name = 'crc_' + name	1✔
322	inner.__name__ = 'crc_' + name	1✔
323	inner.__qualname__ = 'crc_' + name	1✔
324
325	inner.__doc__ = """%s(data) -> int	1✔
326
327	Calculates the %s checksum.
328
329	This is simply the :func:`generic_crc` with these frozen arguments:
330
331	* polynom = 0x%x
332	* width = %d
333	* init = 0x%x
334	* refin = %s
335	* refout = %s
336	* xorout = 0x%x
337
338	%s
339
340	Arguments:
341	data(str): The data to checksum.
342
343	Example:
344	>>> print(%s(b'123456789'))
345	%d
346	""" % (name, name, polynom, width, init, refin, refout, xorout, extra_doc, name, check)
347
348	return inner	1✔
349
350	@staticmethod	1✔
351	def cksum(data):
352	"""cksum(data) -> int
353
354	Calculates the same checksum as returned by the UNIX-tool ``cksum``.
355
356	Arguments:
357	data(str): The data to checksum.
358
359	Example:
360	>>> print(cksum(b'123456789'))
361	930766865
362	"""
363
364	l = len(data)	1✔
365	data += packing.pack(l, 'all', endian='little', sign=False)	1✔
366	return crc.crc_32_posix(data)	1✔
367
368	@staticmethod	1✔
369	def find_crc_function(data, checksum):
370	"""Finds all known CRC functions that hashes a piece of data into a specific
371	checksum. It does this by trying all known CRC functions one after the other.
372
373	Arguments:
374	data(str): Data for which the checksum is known.
375
376	Example:
377	>>> find_crc_function(b'test', 46197)
378	[<function crc_crc_16_dnp at ...>]
379	"""
380	candidates = []	1✔
381	for v in known.all_crcs.keys():	1✔
382	func = getattr(crc, v)	1✔
383	if func(data) == checksum:	1✔
384	candidates.append(func)	1✔
385	return candidates	1✔
386
387
388	tether = sys.modules[__name__]	1✔
389	crc = sys.modules[__name__] = Module()	1✔
390	crc.__doc__ = tether.__doc__	1✔

Gallopsled / pwntools / 2c08a340dd6e0556a03b02dbd505cfffd5babc3a-PR-2067

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