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
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):
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):
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):
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
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):
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(
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,
)
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):
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})