from pyderasn import InvalidValueType
from pyderasn import len_decode
from pyderasn import len_encode
+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
)
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
),
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},
datetime(2010, 1, 2, 3, 4, 5, 0),
)
+ def test_encoding(self):
+ raw = GeneralizedTime(b"20100102030405Z").encode()
+ with assertRaisesRegex(self, DecodeError, "encoding"):
+ GeneralizedTime().decode(raw.replace(b"201001", "привет".encode("utf-8")))
+ with self.assertRaises(DecodeError):
+ GeneralizedTime().decode(raw.replace(b"20100", b"hello"))
+
class TestUTCTime(TimeMixin, CommonMixin, TestCase):
base_klass = UTCTime
1900 + year,
)
+ def test_encoding(self):
+ raw = UTCTime(b"910506234540Z").encode()
+ with assertRaisesRegex(self, DecodeError, "encoding"):
+ UTCTime().decode(raw.replace(b"910506", "привет".encode("utf-8")))
+ with self.assertRaises(DecodeError):
+ UTCTime().decode(raw.replace(b"91050", b"hello"))
+
@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},
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},