# coding: utf-8
# PyDERASN -- Python ASN.1 DER/BER codec with abstract structures
-# Copyright (C) 2017-2018 Sergey Matveev <stargrave@stargrave.org>
+# Copyright (C) 2017-2020 Sergey Matveev <stargrave@stargrave.org>
#
# This program is free software: you can redistribute it and/or modify
# it under the terms of the GNU Lesser General Public License as
-# published by the Free Software Foundation, either version 3 of the
-# License, or (at your option) any later version.
+# published by the Free Software Foundation, version 3 of the License.
#
# This program is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
self.assertTrue(obj.ber_encoded)
self.assertFalse(obj.lenindef)
self.assertTrue(obj.bered)
+ obj = obj.copy()
+ self.assertTrue(obj.ber_encoded)
+ self.assertFalse(obj.lenindef)
+ self.assertTrue(obj.bered)
@given(
integers(min_value=1).map(tag_ctxc),
self.assertFalse(obj.lenindef)
self.assertFalse(obj.ber_encoded)
self.assertTrue(obj.bered)
+ obj = obj.copy()
+ self.assertTrue(obj.expl_lenindef)
+ self.assertFalse(obj.lenindef)
+ self.assertFalse(obj.ber_encoded)
+ self.assertTrue(obj.bered)
self.assertSequenceEqual(tail, junk)
repr(obj)
list(obj.pps())
def _value(value_required):
if not value_required and draw(booleans()):
- return
+ return None
generation_choice = 0
if value_required:
generation_choice = draw(sampled_from((1, 2, 3)))
sampled_from(("0", "1")),
max_size=len(schema),
)))
- elif generation_choice == 2 or draw(booleans()):
+ if generation_choice == 2 or draw(booleans()):
return draw(binary(max_size=len(schema) // 8))
- elif generation_choice == 3 or draw(booleans()):
+ if generation_choice == 3 or draw(booleans()):
return tuple(draw(lists(sampled_from([name for name, _ in schema]))))
return None
value = _value(value_required)
self.assertTrue(obj.ber_encoded)
self.assertEqual(obj.lenindef, lenindef_expected)
self.assertTrue(obj.bered)
+ obj = obj.copy()
+ self.assertTrue(obj.ber_encoded)
+ self.assertEqual(obj.lenindef, lenindef_expected)
+ self.assertTrue(obj.bered)
self.assertEqual(len(encoded), obj.tlvlen)
@given(
self.assertTrue(obj.ber_encoded)
self.assertTrue(obj.lenindef)
self.assertTrue(obj.bered)
+ obj = obj.copy()
+ self.assertTrue(obj.ber_encoded)
+ self.assertTrue(obj.lenindef)
+ self.assertTrue(obj.bered)
@composite
self.assertTrue(obj.ber_encoded)
self.assertEqual(obj.lenindef, lenindef_expected)
self.assertTrue(obj.bered)
+ obj = obj.copy()
+ self.assertTrue(obj.ber_encoded)
+ self.assertEqual(obj.lenindef, lenindef_expected)
+ self.assertTrue(obj.bered)
self.assertEqual(len(encoded), obj.tlvlen)
@given(
repr(err.exception)
obj = ObjectIdentifier(value)
self.assertTrue(obj.ready)
+ self.assertFalse(obj.ber_encoded)
repr(obj)
list(obj.pps())
pprint(obj, big_blobs=True, with_decode_path=True)
ObjectIdentifier((2, 999, 3)),
)
+ def test_nonnormalized_first_arc(self):
+ tampered = (
+ ObjectIdentifier.tag_default +
+ len_encode(2) +
+ b'\x80' +
+ ObjectIdentifier((1, 0)).encode()[-1:]
+ )
+ obj, _ = ObjectIdentifier().decode(tampered, ctx={"bered": True})
+ self.assertTrue(obj.ber_encoded)
+ self.assertTrue(obj.bered)
+ obj = obj.copy()
+ self.assertTrue(obj.ber_encoded)
+ self.assertTrue(obj.bered)
+ with assertRaisesRegex(self, DecodeError, "non normalized arc encoding"):
+ ObjectIdentifier().decode(tampered)
+
+ @given(data_strategy())
+ def test_nonnormalized_arcs(self, d):
+ arcs = d.draw(lists(
+ integers(min_value=0, max_value=100),
+ min_size=1,
+ max_size=5,
+ ))
+ dered = ObjectIdentifier((1, 0) + tuple(arcs)).encode()
+ _, _, lv = tag_strip(dered)
+ _, _, v = len_decode(lv)
+ v_no_first_arc = v[1:]
+ idx_for_tamper = d.draw(integers(
+ min_value=0,
+ max_value=len(v_no_first_arc) - 1,
+ ))
+ tampered = list(bytearray(v_no_first_arc))
+ for _ in range(d.draw(integers(min_value=1, max_value=3))):
+ tampered.insert(idx_for_tamper, 0x80)
+ tampered = bytes(bytearray(tampered))
+ tampered = (
+ ObjectIdentifier.tag_default +
+ len_encode(len(tampered)) +
+ tampered
+ )
+ obj, _ = ObjectIdentifier().decode(tampered, ctx={"bered": True})
+ self.assertTrue(obj.ber_encoded)
+ self.assertTrue(obj.bered)
+ obj = obj.copy()
+ self.assertTrue(obj.ber_encoded)
+ self.assertTrue(obj.bered)
+ with assertRaisesRegex(self, DecodeError, "non normalized arc encoding"):
+ ObjectIdentifier().decode(tampered)
+
@composite
def enumerated_values_strategy(draw, schema=None, do_expl=False):
self.assertTrue(obj.ber_encoded)
self.assertFalse(obj.lenindef)
self.assertTrue(obj.bered)
+ obj = obj.copy()
+ self.assertTrue(obj.ber_encoded)
+ self.assertFalse(obj.lenindef)
+ self.assertTrue(obj.bered)
obj, tail = VisibleString().decode(
hexdec("3A8004034A6F6E040265730000"),
self.assertTrue(obj.ber_encoded)
self.assertTrue(obj.lenindef)
self.assertTrue(obj.bered)
+ obj = obj.copy()
+ self.assertTrue(obj.ber_encoded)
+ self.assertTrue(obj.lenindef)
+ self.assertTrue(obj.bered)
class TestGeneralString(
pprint(obj, big_blobs=True, with_decode_path=True)
self.assertFalse(obj.expled)
obj_encoded = obj.encode()
+ self.additional_symmetric_check(value, obj_encoded)
obj_expled = obj(value, expl=tag_expl)
self.assertTrue(obj_expled.expled)
repr(obj_expled)
min_datetime = datetime(1900, 1, 1)
max_datetime = datetime(9999, 12, 31)
+ def additional_symmetric_check(self, value, obj_encoded):
+ if value.microsecond > 0:
+ self.assertFalse(obj_encoded.endswith(b"0Z"))
+
+ def test_x690_vector_valid(self):
+ for data in ((
+ b"19920521000000Z",
+ b"19920622123421Z",
+ b"19920722132100.3Z",
+ )):
+ GeneralizedTime(data)
+
+ def test_x690_vector_invalid(self):
+ for data in ((
+ b"19920520240000Z",
+ b"19920622123421.0Z",
+ b"19920722132100.30Z",
+ )):
+ with self.assertRaises(DecodeError) as err:
+ GeneralizedTime(data)
+ repr(err.exception)
+
def test_go_vectors_invalid(self):
for data in ((
b"20100102030405",
junk
)
+ def test_ns_fractions(self):
+ GeneralizedTime(b"20010101000000.000001Z")
+ with assertRaisesRegex(self, DecodeError, "only microsecond fractions"):
+ GeneralizedTime(b"20010101000000.0000001Z")
+
class TestUTCTime(TimeMixin, CommonMixin, TestCase):
base_klass = UTCTime
min_datetime = datetime(2000, 1, 1)
max_datetime = datetime(2049, 12, 31)
+ def additional_symmetric_check(self, value, obj_encoded):
+ pass
+
+ def test_x690_vector_valid(self):
+ for data in ((
+ b"920521000000Z",
+ b"920622123421Z",
+ b"920722132100Z",
+ )):
+ UTCTime(data)
+
+ def test_x690_vector_invalid(self):
+ for data in ((
+ b"920520240000Z",
+ b"9207221321Z",
+ )):
+ with self.assertRaises(DecodeError) as err:
+ UTCTime(data)
+ repr(err.exception)
+
def test_go_vectors_invalid(self):
for data in ((
b"a10506234540Z",
self.assertTrue(obj.lenindef)
self.assertFalse(obj.ber_encoded)
self.assertTrue(obj.bered)
+ obj = obj.copy()
+ self.assertTrue(obj.lenindef)
+ self.assertFalse(obj.ber_encoded)
+ self.assertTrue(obj.bered)
repr(obj)
list(obj.pps())
pprint(obj, big_blobs=True, with_decode_path=True)
value = None
if draw(booleans()):
value = seq_klass()
- value._value = {
- k: v for k, v in draw(dictionaries(
- integers(),
- one_of(
- booleans().map(Boolean),
- integers().map(Integer),
- ),
- )).items()
- }
+ value._value = draw(dictionaries(
+ integers(),
+ one_of(
+ booleans().map(Boolean),
+ integers().map(Integer),
+ ),
+ ))
schema = None
if draw(booleans()):
schema = list(draw(dictionaries(
default = None
if draw(booleans()):
default = seq_klass()
- default._value = {
- k: v for k, v in draw(dictionaries(
- integers(),
- one_of(
- booleans().map(Boolean),
- integers().map(Integer),
- ),
- )).items()
- }
+ default._value = draw(dictionaries(
+ integers(),
+ one_of(
+ booleans().map(Boolean),
+ integers().map(Integer),
+ ),
+ ))
optional = draw(one_of(none(), booleans()))
_decoded = (
draw(integers(min_value=0)),
self.assertDictEqual(ctx_copied, ctx_dummy)
self.assertTrue(seq_decoded_lenindef.lenindef)
self.assertTrue(seq_decoded_lenindef.bered)
+ seq_decoded_lenindef = seq_decoded_lenindef.copy()
+ self.assertTrue(seq_decoded_lenindef.lenindef)
+ self.assertTrue(seq_decoded_lenindef.bered)
with self.assertRaises(DecodeError):
seq.decode(seq_encoded_lenindef[:-1], ctx={"bered": True})
with self.assertRaises(DecodeError):
seq_decoded, _ = seq_with_default.decode(seq_encoded, ctx=ctx)
self.assertTrue(seq_decoded.ber_encoded)
self.assertTrue(seq_decoded.bered)
+ seq_decoded = seq_decoded.copy()
+ self.assertTrue(seq_decoded.ber_encoded)
+ self.assertTrue(seq_decoded.bered)
for name, value in _schema:
self.assertEqual(seq_decoded[name], seq_with_default[name])
self.assertEqual(seq_decoded[name], value)
with self.assertRaises(TagMismatch):
seq_missing.decode(seq_encoded)
- @given(data_strategy())
- def test_bered(self, d):
+ def test_bered(self):
class Seq(self.base_klass):
schema = (("underlying", Boolean()),)
encoded = Boolean.tag_default + len_encode(1) + b"\x01"
self.assertFalse(decoded.ber_encoded)
self.assertFalse(decoded.lenindef)
self.assertTrue(decoded.bered)
+ decoded = decoded.copy()
+ self.assertFalse(decoded.ber_encoded)
+ self.assertFalse(decoded.lenindef)
+ self.assertTrue(decoded.bered)
class Seq(self.base_klass):
schema = (("underlying", OctetString()),)
self.assertFalse(decoded.ber_encoded)
self.assertFalse(decoded.lenindef)
self.assertTrue(decoded.bered)
+ decoded = decoded.copy()
+ self.assertFalse(decoded.ber_encoded)
+ self.assertFalse(decoded.lenindef)
+ self.assertTrue(decoded.bered)
class TestSequence(SeqMixing, CommonMixin, TestCase):
seq_decoded, _ = Seq().decode(seq_encoded, ctx=ctx)
self.assertTrue(seq_decoded.ber_encoded)
self.assertTrue(seq_decoded.bered)
+ seq_decoded = seq_decoded.copy()
+ self.assertTrue(seq_decoded.ber_encoded)
+ self.assertTrue(seq_decoded.bered)
self.assertSequenceEqual(
[bytes(seq_decoded[str(i)]) for i, t in enumerate(tags)],
- [t for t in tags],
+ tags,
)
)
self.assertTrue(obj_decoded_lenindef.lenindef)
self.assertTrue(obj_decoded_lenindef.bered)
+ obj_decoded_lenindef = obj_decoded_lenindef.copy()
+ self.assertTrue(obj_decoded_lenindef.lenindef)
+ self.assertTrue(obj_decoded_lenindef.bered)
repr(obj_decoded_lenindef)
list(obj_decoded_lenindef.pps())
pprint(obj_decoded_lenindef, big_blobs=True, with_decode_path=True)
with self.assertRaises(DecodeError):
obj.decode(obj_encoded_lenindef[:-2], ctx={"bered": True})
- @given(data_strategy())
- def test_bered(self, d):
+ def test_bered(self):
class SeqOf(self.base_klass):
schema = Boolean()
encoded = Boolean(False).encode()
self.assertFalse(decoded.ber_encoded)
self.assertFalse(decoded.lenindef)
self.assertTrue(decoded.bered)
+ decoded = decoded.copy()
+ self.assertFalse(decoded.ber_encoded)
+ self.assertFalse(decoded.lenindef)
+ self.assertTrue(decoded.bered)
class SeqOf(self.base_klass):
schema = OctetString()
self.assertFalse(decoded.ber_encoded)
self.assertFalse(decoded.lenindef)
self.assertTrue(decoded.bered)
+ decoded = decoded.copy()
+ self.assertFalse(decoded.ber_encoded)
+ self.assertFalse(decoded.lenindef)
+ self.assertTrue(decoded.bered)
class TestSequenceOf(SeqOfMixing, CommonMixin, TestCase):
seq_decoded, _ = Seq().decode(seq_encoded, ctx=ctx)
self.assertTrue(seq_decoded.ber_encoded)
self.assertTrue(seq_decoded.bered)
+ seq_decoded = seq_decoded.copy()
+ self.assertTrue(seq_decoded.ber_encoded)
+ self.assertTrue(seq_decoded.bered)
self.assertSequenceEqual(
[obj.encode() for obj in seq_decoded],
values,
chosen_id = oids[chosen]
pp = _pp(asn1_type_name=ObjectIdentifier.asn1_type_name, value=chosen)
self.assertNotIn(chosen_id, pp_console_row(pp))
- self.assertIn(chosen_id, pp_console_row(pp, oids=oids))
+ self.assertIn(
+ chosen_id,
+ pp_console_row(pp, oid_maps=[{'whatever': 'whenever'}, oids]),
+ )
class TestAutoAddSlots(TestCase):
decoded, _ = seq.decode(raw, ctx={"allow_default_values": True})
self.assertTrue(decoded.ber_encoded)
self.assertTrue(decoded.bered)
+ decoded = decoded.copy()
+ self.assertTrue(decoded.ber_encoded)
+ self.assertTrue(decoded.bered)
decoded, _ = seq.decode(raw, ctx={"bered": True})
self.assertTrue(decoded.ber_encoded)
self.assertTrue(decoded.bered)
+ decoded = decoded.copy()
+ self.assertTrue(decoded.ber_encoded)
+ self.assertTrue(decoded.bered)
class TestX690PrefixedType(TestCase):