def test_long_object_identifier(self) -> None:
enc = asn1.Encoder()
enc.write("39.2.3", asn1.Number.ObjectIdentifier)
res = enc.output()
assert res == b"\x06\x03\x8c\x1a\x03"
enc = asn1.Encoder()
enc.write("1.39.3", asn1.Number.ObjectIdentifier)
res = enc.output()
assert res == b"\x06\x02\x4f\x03"
enc = asn1.Encoder()
enc.write("1.2.300000", asn1.Number.ObjectIdentifier)
res = enc.output()
assert res == b"\x06\x04\x2a\x92\xa7\x60"
def test_set_of(self) -> None:
enc = asn1.Encoder()
with enc.enter(asn1.Number.Set):
enc.write(1)
enc.write(2)
res = enc.output()
assert res == b"\x31\x06\x02\x01\x01\x02\x01\x02"
def test_big_negative_numbers(self, value: int) -> None:
encoder = asn1.Encoder()
encoder.write(value, asn1.Number.Integer)
encoded_bytes = encoder.output()
decoder = asn1.Decoder(encoded_bytes)
tag, val = decoder.read()
assert val == value
def test_set(self) -> None:
enc = asn1.Encoder()
with enc.enter(asn1.Number.Set):
enc.write(1)
enc.write(b"foo")
res = enc.output()
assert res == b"\x31\x08\x02\x01\x01\x04\x03foo"
def test_long_integer(self) -> None:
enc = asn1.Encoder()
enc.write(0x0102030405060708090A0B0C0D0E0F)
res = enc.output()
assert (
res
== b"\x02\x0f\x01\x02\x03\x04\x05\x06\x07\x08\x09\x0a\x0b\x0c\x0d\x0e\x0f"
)
def test_long_negative_integer(self) -> None:
enc = asn1.Encoder()
enc.write(-0x0102030405060708090A0B0C0D0E0F)
res = enc.output()
assert (
res
== b"\x02\x0f\xfe\xfd\xfc\xfb\xfa\xf9\xf8\xf7\xf6\xf5\xf4\xf3\xf2\xf1\xf1"
)
def test_negative_integer(self) -> None:
enc = asn1.Encoder()
enc.write(-1)
res = enc.output()
assert res == b"\x02\x01\xff"
def test_error_object_identifier(self, value) -> None:
enc = asn1.Encoder()
with pytest.raises(asn1.Error):
enc.write(value, asn1.Number.ObjectIdentifier)
def test_error_stack(self) -> None:
enc = asn1.Encoder()
with enc.enter(asn1.Number.Sequence):
with pytest.raises(asn1.Error):
enc.output()
def test_long_tag_length(self) -> None:
enc = asn1.Encoder()
enc.write(b"x" * 0xFFFF)
res = enc.output()
assert res == b"\x04\x82\xff\xff" + b"x" * 0xFFFF
def test_unicode_printable_string(self) -> None:
enc = asn1.Encoder()
enc.write("fooé", nr=asn1.Number.PrintableString)
res = enc.output()
assert res == b"\x13\x05\x66\x6f\x6f\xc3\xa9"
def test_printable_string(self) -> None:
enc = asn1.Encoder()
enc.write("foo", nr=asn1.Number.PrintableString)
res = enc.output()
assert res == b"\x13\x03foo"
def test_twos_complement_boundaries(self, number: int,
result: bytes) -> None:
enc = asn1.Encoder()
enc.write(number)
assert enc.output() == result
def test_boolean(self) -> None:
enc = asn1.Encoder()
enc.write(True, asn1.Number.Boolean)
res = enc.output()
assert res == b"\x01\x01\xff"
def test_enumerated(self) -> None:
enc = asn1.Encoder()
enc.write(1, asn1.Number.Enumerated)
res = enc.output()
assert res == b"\x0a\x01\x01"
def test_ipaddress(self) -> None:
enc = asn1.Encoder()
enc.write(ipaddress.IPv4Address("127.0.0.1"), asn1.Number.IPAddress)
res = enc.output()
assert res == b"\x40\x04\x7f\x00\x00\x01"
def test_real_object_identifier(self) -> None:
enc = asn1.Encoder()
enc.write("1.2.840.113554.1.2.1.1", asn1.Number.ObjectIdentifier)
res = enc.output()
assert res == b"\x06\x0a\x2a\x86\x48\x86\xf7\x12\x01\x02\x01\x01"
def test_object_identifier(self) -> None:
enc = asn1.Encoder()
enc.write("1.2.3", asn1.Number.ObjectIdentifier)
res = enc.output()
assert res == b"\x06\x02\x2a\x03"
def test_octet_string(self) -> None:
enc = asn1.Encoder()
enc.write(b"foo")
res = enc.output()
assert res == b"\x04\x03foo"
def test_context(self) -> None:
enc = asn1.Encoder()
with enc.enter(1, asn1.Class.Context):
enc.write(1)
res = enc.output()
assert res == b"\xa1\x03\x02\x01\x01"
def test_unicode_octet_string(self) -> None:
enc = asn1.Encoder()
enc.write("fooé")
res = enc.output()
assert res == b"\x04\x05\x66\x6f\x6f\xc3\xa9"
def test_application(self) -> None:
enc = asn1.Encoder()
with enc.enter(1, asn1.Class.Application):
enc.write(1)
res = enc.output()
assert res == b"\x61\x03\x02\x01\x01"
def test_null(self) -> None:
enc = asn1.Encoder()
enc.write(None)
res = enc.output()
assert res == b"\x05\x00"
def test_private(self) -> None:
enc = asn1.Encoder()
with enc.enter(1, asn1.Class.Private):
enc.write(1)
res = enc.output()
assert res == b"\xe1\x03\x02\x01\x01"
