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
from pyderasn import NumericString
settings.register_profile("local", settings(
deadline=5000,
- perform_health_check=False,
))
settings.load_profile("local")
LONG_TEST_MAX_EXAMPLES = settings().max_examples * 4
binary().filter(lambda x: not x.startswith(EOC)),
)
def test_ber_expl_no_eoc(self, expl, junk):
- encoded = expl + b"\x80" + Boolean(False).encode()
+ encoded = expl + LENINDEF + Boolean(False).encode()
with assertRaisesRegex(self, DecodeError, "no EOC"):
Boolean(expl=expl).decode(encoded + junk, ctx={"bered": True})
obj, tail = Boolean(expl=expl).decode(
for value in values:
encoded += (
expl +
- b"\x80" +
+ LENINDEF +
Boolean(value).encode() +
EOC
)
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):
def chunk_constructed(contents):
return (
tag_encode(form=TagFormConstructed, num=3) +
- b"\x80" +
+ LENINDEF +
b"".join(BitString(content).encode() for content in contents) +
EOC
)
bit_len_expected += chunk_last.bit_len
encoded_indefinite = (
tag_encode(form=TagFormConstructed, num=impl) +
- b"\x80" +
+ LENINDEF +
b"".join(chunks) +
chunk_last.encode() +
EOC
bs = BitString(b"data").encode()
with self.assertRaises(NotEnoughData) as err:
BitString().decode(
- tag_encode(3, form=TagFormConstructed) + b"\x80" + chunks * bs,
+ tag_encode(3, form=TagFormConstructed) + LENINDEF + chunks * bs,
offset=offset,
decode_path=decode_path,
ctx={"bered": True},
def test_ber_indefinite_no_chunks(self, offset, decode_path):
with assertRaisesRegex(self, DecodeError, "no chunks") as err:
BitString().decode(
- tag_encode(3, form=TagFormConstructed) + b"\x80" + EOC,
+ tag_encode(3, form=TagFormConstructed) + LENINDEF + EOC,
offset=offset,
decode_path=decode_path,
ctx={"bered": True},
BitString().decode(
(
tag_encode(3, form=TagFormConstructed) +
- b"\x80" +
+ LENINDEF +
b"".join(chunks) +
EOC
),
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):
def chunk_constructed(contents):
return (
tag_encode(form=TagFormConstructed, num=4) +
- b"\x80" +
+ LENINDEF +
b"".join(OctetString(content).encode() for content in contents) +
EOC
)
payload_expected += payload
encoded_indefinite = (
tag_encode(form=TagFormConstructed, num=impl) +
- b"\x80" +
+ LENINDEF +
b"".join(chunks) +
EOC
)
bs = OctetString(b"data").encode()
with self.assertRaises(NotEnoughData) as err:
OctetString().decode(
- tag_encode(4, form=TagFormConstructed) + b"\x80" + chunks * bs,
+ tag_encode(4, form=TagFormConstructed) + LENINDEF + chunks * bs,
offset=offset,
decode_path=decode_path,
ctx={"bered": True},
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):
chunk = Boolean(False, expl=expl).encode()
encoded = (
OctetString.tag_default +
- b"\x80" +
+ LENINDEF +
b"".join([chunk] * chunks) +
EOC
)
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,
)
t, _, lv = tag_strip(seq_encoded)
_, _, v = len_decode(lv)
- seq_encoded_lenindef = t + b"\x80" + v + EOC
+ seq_encoded_lenindef = t + LENINDEF + v + EOC
seq_decoded_lenindef, tail_lenindef = seq.decode(
seq_encoded_lenindef + tail_junk,
ctx={"bered": True},
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):
t, _, lv = tag_strip(obj_encoded)
_, _, v = len_decode(lv)
- obj_encoded_lenindef = t + b"\x80" + v + EOC
+ obj_encoded_lenindef = t + LENINDEF + v + EOC
obj_decoded_lenindef, tail_lenindef = obj.decode(
obj_encoded_lenindef + tail_junk,
ctx={"bered": True},