X-Git-Url: http://www.git.cypherpunks.ru/?a=blobdiff_plain;f=tests%2Ftest_pyderasn.py;h=adad7e9b88f9ef475e7e56b1d2f7931b836b7541;hb=73db29cf680d46539f651e742acd1942414ce9a1;hp=c730633c5a8433bd1badd2a05f7ca20d5baeed43;hpb=eeee170c0c7f0c89370c074c6e39592b1d7eca1d;p=pyderasn.git diff --git a/tests/test_pyderasn.py b/tests/test_pyderasn.py index c730633..adad7e9 100644 --- a/tests/test_pyderasn.py +++ b/tests/test_pyderasn.py @@ -77,6 +77,9 @@ from pyderasn import InvalidOID from pyderasn import InvalidValueType from pyderasn import len_decode from pyderasn import len_encode +from pyderasn import LEN_YYMMDDHHMMSSZ +from pyderasn import LEN_YYYYMMDDHHMMSSDMZ +from pyderasn import LEN_YYYYMMDDHHMMSSZ from pyderasn import LENINDEF from pyderasn import NotEnoughData from pyderasn import Null @@ -806,9 +809,19 @@ class TestInteger(CommonMixin, TestCase): with self.assertRaises(BoundsError) as err: Integer(value=values[0], bounds=(values[1], values[2])) repr(err.exception) + with assertRaisesRegex(self, DecodeError, "bounds") as err: + Integer(bounds=(values[1], values[2])).decode( + Integer(values[0]).encode() + ) + repr(err.exception) with self.assertRaises(BoundsError) as err: Integer(value=values[2], bounds=(values[0], values[1])) repr(err.exception) + with assertRaisesRegex(self, DecodeError, "bounds") as err: + Integer(bounds=(values[0], values[1])).decode( + Integer(values[2]).encode() + ) + repr(err.exception) @given(data_strategy()) def test_call(self, d): @@ -1759,10 +1772,20 @@ class TestOctetString(CommonMixin, TestCase): with self.assertRaises(BoundsError) as err: OctetString(value=value, bounds=(bound_min, bound_max)) repr(err.exception) + with assertRaisesRegex(self, DecodeError, "bounds") as err: + OctetString(bounds=(bound_min, bound_max)).decode( + OctetString(value).encode() + ) + repr(err.exception) value = d.draw(binary(min_size=bound_max + 1)) with self.assertRaises(BoundsError) as err: OctetString(value=value, bounds=(bound_min, bound_max)) repr(err.exception) + with assertRaisesRegex(self, DecodeError, "bounds") as err: + OctetString(bounds=(bound_min, bound_max)).decode( + OctetString(value).encode() + ) + repr(err.exception) @given(data_strategy()) def test_call(self, d): @@ -2975,10 +2998,20 @@ class StringMixin(object): with self.assertRaises(BoundsError) as err: self.base_klass(value=value, bounds=(bound_min, bound_max)) repr(err.exception) + with assertRaisesRegex(self, DecodeError, "bounds") as err: + self.base_klass(bounds=(bound_min, bound_max)).decode( + self.base_klass(value).encode() + ) + repr(err.exception) value = d.draw(text(alphabet=self.text_alphabet(), min_size=bound_max + 1)) with self.assertRaises(BoundsError) as err: self.base_klass(value=value, bounds=(bound_min, bound_max)) repr(err.exception) + with assertRaisesRegex(self, DecodeError, "bounds") as err: + self.base_klass(bounds=(bound_min, bound_max)).decode( + self.base_klass(value).encode() + ) + repr(err.exception) @given(data_strategy()) def test_call(self, d): @@ -3609,6 +3642,48 @@ class TestGeneralizedTime(TimeMixin, CommonMixin, TestCase): datetime(2010, 1, 2, 3, 4, 5, 0), ) + @given( + binary( + min_size=(LEN_YYYYMMDDHHMMSSZ - 1) // 2, + max_size=(LEN_YYYYMMDDHHMMSSZ - 1) // 2, + ), + binary(min_size=1, max_size=1), + binary( + min_size=(LEN_YYYYMMDDHHMMSSZ - 1) // 2, + max_size=(LEN_YYYYMMDDHHMMSSZ - 1) // 2, + ), + ) + def test_junk(self, part0, part1, part2): + junk = part0 + part1 + part2 + assume(not (set(junk) <= set(digits.encode("ascii")))) + with self.assertRaises(DecodeError): + GeneralizedTime().decode( + GeneralizedTime.tag_default + + len_encode(len(junk)) + + junk + ) + + @given( + binary( + min_size=(LEN_YYYYMMDDHHMMSSDMZ - 1) // 2, + max_size=(LEN_YYYYMMDDHHMMSSDMZ - 1) // 2, + ), + binary(min_size=1, max_size=1), + binary( + min_size=(LEN_YYYYMMDDHHMMSSDMZ - 1) // 2, + max_size=(LEN_YYYYMMDDHHMMSSDMZ - 1) // 2, + ), + ) + def test_junk_dm(self, part0, part1, part2): + junk = part0 + part1 + part2 + assume(not (set(junk) <= set(digits.encode("ascii")))) + with self.assertRaises(DecodeError): + GeneralizedTime().decode( + GeneralizedTime.tag_default + + len_encode(len(junk)) + + junk + ) + class TestUTCTime(TimeMixin, CommonMixin, TestCase): base_klass = UTCTime @@ -3673,6 +3748,27 @@ class TestUTCTime(TimeMixin, CommonMixin, TestCase): 1900 + year, ) + @given( + binary( + min_size=(LEN_YYMMDDHHMMSSZ - 1) // 2, + max_size=(LEN_YYMMDDHHMMSSZ - 1) // 2, + ), + binary(min_size=1, max_size=1), + binary( + min_size=(LEN_YYMMDDHHMMSSZ - 1) // 2, + max_size=(LEN_YYMMDDHHMMSSZ - 1) // 2, + ), + ) + def test_junk(self, part0, part1, part2): + junk = part0 + part1 + part2 + assume(not (set(junk) <= set(digits.encode("ascii")))) + with self.assertRaises(DecodeError): + UTCTime().decode( + UTCTime.tag_default + + len_encode(len(junk)) + + junk + ) + @composite def any_values_strategy(draw, do_expl=False): @@ -3928,12 +4024,18 @@ class TestAny(CommonMixin, TestCase): def choice_values_strategy(draw, value_required=False, schema=None, do_expl=False): if schema is None: names = list(draw(sets(text_letters(), min_size=1, max_size=5))) - tags = [tag_encode(tag) for tag in draw(sets( - integers(min_value=0), + tags = [{tag_type: tag_value} for tag_type, tag_value in draw(sets( + one_of( + tuples(just("impl"), integers(min_value=0).map(tag_encode)), + tuples(just("expl"), integers(min_value=0).map(tag_ctxp)), + ), min_size=len(names), max_size=len(names), ))] - schema = [(name, Integer(impl=tag)) for name, tag in zip(names, tags)] + schema = [ + (name, Integer(**tag_kwargs)) + for name, tag_kwargs in zip(names, tags) + ] value = None if value_required or draw(booleans()): value = draw(tuples( @@ -4175,8 +4277,8 @@ class TestChoice(CommonMixin, TestCase): self.assertEqual(obj_decoded.expl_offset, offset) self.assertSequenceEqual( obj_expled_encoded[ - obj_decoded.value.offset - offset: - obj_decoded.value.offset + obj_decoded.value.tlvlen - offset + obj_decoded.value.fulloffset - offset: + obj_decoded.value.fulloffset + obj_decoded.value.fulllen - offset ], obj_encoded, ) @@ -5008,17 +5110,27 @@ class SeqOfMixing(object): schema = Boolean() bound_min = d.draw(integers(min_value=1, max_value=1 << 7)) bound_max = d.draw(integers(min_value=bound_min, max_value=1 << 7)) - value = [Boolean()] * d.draw(integers(max_value=bound_min - 1)) + value = [Boolean(False)] * d.draw(integers(max_value=bound_min - 1)) with self.assertRaises(BoundsError) as err: SeqOf(value=value, bounds=(bound_min, bound_max)) repr(err.exception) - value = [Boolean()] * d.draw(integers( + with assertRaisesRegex(self, DecodeError, "bounds") as err: + SeqOf(bounds=(bound_min, bound_max)).decode( + SeqOf(value).encode() + ) + repr(err.exception) + value = [Boolean(True)] * d.draw(integers( min_value=bound_max + 1, max_value=bound_max + 10, )) with self.assertRaises(BoundsError) as err: SeqOf(value=value, bounds=(bound_min, bound_max)) repr(err.exception) + with assertRaisesRegex(self, DecodeError, "bounds") as err: + SeqOf(bounds=(bound_min, bound_max)).decode( + SeqOf(value).encode() + ) + repr(err.exception) @given(integers(min_value=1, max_value=10)) def test_out_of_bounds(self, bound_max): @@ -5810,3 +5922,13 @@ class TestX690PrefixedType(TestCase): VisibleString("Jones", impl=tag_ctxp(2)).encode(), hexdec("82054A6F6E6573"), ) + + +class TestExplOOB(TestCase): + def runTest(self): + expl = tag_ctxc(123) + raw = Integer(123).encode() + Integer(234).encode() + raw = b"".join((expl, len_encode(len(raw)), raw)) + with assertRaisesRegex(self, DecodeError, "explicit tag out-of-bound"): + Integer(expl=expl).decode(raw) + Integer(expl=expl).decode(raw, ctx={"allow_expl_oob": True})