Remove asn1tools test dependency in favor of hardcoded reference vectors.

AI-Assisted: yes (Cursor AI)

Author: Nils Weiss

.config/ci/install.ps1

@@ -19,6 +19,3 @@ python -m pip install --upgrade pip setuptools wheel --ignore-installed
 
 # Make sure tox is installed and up to date
 python -m pip install -U tox --ignore-installed
-
-# Optional test dependency for ASN.1 OER interoperability tests
-python -m pip install asn1tools

.config/ci/install.sh

@@ -53,8 +53,5 @@ python -m pip install --upgrade pip setuptools wheel --ignore-installed
 # Make sure tox is installed and up to date
 python -m pip install -U tox --ignore-installed
 
-# Optional test dependency for ASN.1 OER interoperability tests
-python -m pip install asn1tools
-
 # Dump Environment (so that we can check PATH, UT_FLAGS, etc.)
 set

test/scapy/layers/asn1.uts

@@ -207,14 +207,11 @@ ASN1_BOOLEAN(1).enc(ASN1_Codecs.OER) == b"\xff"
 = OER ASN1 null object
 ASN1_NULL(None).enc(ASN1_Codecs.OER) == b""
 
-+ ASN.1 OER interoperability (asn1tools)
-= asn1tools availability probe
-from test.scapy.layers.oer_iop import require_asn1tools
-HAS_ASN1TOOLS_OER = require_asn1tools()
-= primitive encode interop with asn1tools
-(not HAS_ASN1TOOLS_OER) or __import__('test.scapy.layers.oer_iop', fromlist=['check_primitive_interop']).check_primitive_interop()
-= scapy encode asn1tools decode
-(not HAS_ASN1TOOLS_OER) or __import__('test.scapy.layers.oer_iop', fromlist=['check_asn1tools_decode_scapy_encode']).check_asn1tools_decode_scapy_encode()
++ ASN.1 OER interoperability (reference vectors)
+= primitive encode interop
+__import__('test.scapy.layers.oer_iop', fromlist=['check_primitive_interop']).check_primitive_interop()
+= scapy encode reference decode
+__import__('test.scapy.layers.oer_iop', fromlist=['check_scapy_encode_reference_decode']).check_scapy_encode_reference_decode()
 
 + ASN.1 OER review fixes
 = OER fixed integer decode roundtrip
@@ -342,19 +339,16 @@ x.val == 1 and r == b""
 ASN1_INTEGER(42).enc(ASN1_Codecs.PER) == b"\x01*"
 = UPER codec registration
 ASN1_Class_UNIVERSAL.INTEGER.get_codec(ASN1_Codecs.PER) is UPERcodec_INTEGER
-= asn1tools availability probe for UPER
-from test.scapy.layers.uper_iop import require_asn1tools
-HAS_ASN1TOOLS_UPER = require_asn1tools()
 
 + ASN.1 UPER codec roundtrips
 = UPER codec primitive roundtrips
 __import__('test.scapy.layers.uper_codec', fromlist=['check_uper_codec_roundtrips']).check_uper_codec_roundtrips()
-= UPER codec asn1tools decode interop
-(not HAS_ASN1TOOLS_UPER) or __import__('test.scapy.layers.uper_codec', fromlist=['check_uper_codec_asn1tools_decode']).check_uper_codec_asn1tools_decode()
-= UPER codec scapy encode asn1tools decode
-(not HAS_ASN1TOOLS_UPER) or __import__('test.scapy.layers.uper_codec', fromlist=['check_uper_codec_scapy_decode_asn1tools']).check_uper_codec_scapy_decode_asn1tools()
+= UPER codec reference decode interop
+__import__('test.scapy.layers.uper_codec', fromlist=['check_uper_codec_reference_decode']).check_uper_codec_reference_decode()
+= UPER codec scapy encode reference interop
+__import__('test.scapy.layers.uper_codec', fromlist=['check_uper_codec_encode_reference']).check_uper_codec_encode_reference()
 = UPER codec OID encode interop
-(not HAS_ASN1TOOLS_UPER) or __import__('test.scapy.layers.uper_codec', fromlist=['check_uper_codec_oid_encode_interop']).check_uper_codec_oid_encode_interop()
+__import__('test.scapy.layers.uper_codec', fromlist=['check_uper_codec_oid_encode_interop']).check_uper_codec_oid_encode_interop()
 = UPER codec OID roundtrip
 __import__('test.scapy.layers.uper_codec', fromlist=['check_uper_codec_oid_roundtrip']).check_uper_codec_oid_roundtrip()
 
@@ -380,25 +374,23 @@ __import__('test.scapy.layers.uper_helpers', fromlist=['check_uper_join_encoding
 = UPER chained encode into
 __import__('test.scapy.layers.uper_helpers', fromlist=['check_uper_chained_encode_into']).check_uper_chained_encode_into()
 
-+ ASN.1 UPER interoperability (asn1tools)
-= UPER primitive encode interop with asn1tools
-(not HAS_ASN1TOOLS_UPER) or __import__('test.scapy.layers.uper_iop', fromlist=['check_primitive_interop']).check_primitive_interop()
-= UPER composite encode interop with asn1tools
-(not HAS_ASN1TOOLS_UPER) or __import__('test.scapy.layers.uper_iop', fromlist=['check_composite_interop']).check_composite_interop()
-= UPER composite decode interop with asn1tools
-(not HAS_ASN1TOOLS_UPER) or __import__('test.scapy.layers.uper_iop', fromlist=['check_composite_decode_interop']).check_composite_decode_interop()
-= UPER packet asn1tools interop
-(not HAS_ASN1TOOLS_UPER) or __import__('test.scapy.layers.uper_iop', fromlist=['check_packet_asn1tools_interop']).check_packet_asn1tools_interop()
++ ASN.1 UPER interoperability (reference vectors)
+= UPER primitive encode interop
+__import__('test.scapy.layers.uper_iop', fromlist=['check_primitive_interop']).check_primitive_interop()
+= UPER composite encode interop
+__import__('test.scapy.layers.uper_iop', fromlist=['check_composite_interop']).check_composite_interop()
+= UPER packet reference interop
+__import__('test.scapy.layers.uper_iop', fromlist=['check_packet_reference_interop']).check_packet_reference_interop()
 = UPER packet decode vectors
 __import__('test.scapy.layers.uper_iop', fromlist=['check_packet_decode_vectors']).check_packet_decode_vectors()
 
 + ASN.1 UPER asn1scc interoperability
-= asn1scc vector encode interop with asn1tools
-(not HAS_ASN1TOOLS_UPER) or __import__('test.scapy.layers.uper_asn1scc_iop', fromlist=['check_asn1scc_vectors']).check_asn1scc_vectors()
-= asn1scc README Message uPER reference (asn1tools)
-(not HAS_ASN1TOOLS_UPER) or __import__('test.scapy.layers.uper_asn1scc_iop', fromlist=['check_asn1scc_readme_message_reference']).check_asn1scc_readme_message_reference()
+= asn1scc vector encode interop
+__import__('test.scapy.layers.uper_asn1scc_iop', fromlist=['check_asn1scc_vectors']).check_asn1scc_vectors()
+= asn1scc README Message uPER reference
+__import__('test.scapy.layers.uper_asn1scc_iop', fromlist=['check_asn1scc_readme_message_reference']).check_asn1scc_readme_message_reference()
 = asn1scc README MessagePrefix Scapy interop
-(not HAS_ASN1TOOLS_UPER) or __import__('test.scapy.layers.uper_asn1scc_iop', fromlist=['check_asn1scc_readme_message_prefix']).check_asn1scc_readme_message_prefix()
+__import__('test.scapy.layers.uper_asn1scc_iop', fromlist=['check_asn1scc_readme_message_prefix']).check_asn1scc_readme_message_prefix()
 
 + ASN.1 UPER packets and fields
 = UPER field fixed size

test/scapy/layers/oer_iop.py

@@ -5,20 +5,10 @@
 """
 OER interoperability helpers.
 
-Cross-check Scapy's OER codec against asn1tools when available.
-asn1tools is an optional test dependency (pip install asn1tools).
+Cross-check Scapy's OER codec against reference encodings (from asn1tools).
 Reference vectors are taken from asn1tools/tests/test_oer.py.
 """
 
-from typing import Any, Callable, List, Optional, Tuple
-
-try:
-    import asn1tools
-    HAS_ASN1TOOLS = True
-except ImportError:
-    asn1tools = None  # type: ignore
-    HAS_ASN1TOOLS = False
-
 from scapy.asn1.oer import (
     OERcodec_BIT_STRING,
     OERcodec_BOOLEAN,
@@ -27,177 +17,119 @@
     OERcodec_NULL,
     OERcodec_OID,
     OERcodec_STRING,
-    OER_len_dec,
-    OER_len_enc,
-    OER_signed_integer_dec,
     OER_signed_integer_enc,
-    OER_unsigned_integer_dec,
     OER_unsigned_integer_enc,
 )
 
-
-ASN1TOOLS_INTEGER_SPEC = (
-    "Foo DEFINITIONS AUTOMATIC TAGS ::= "
-    "BEGIN "
-    "A ::= INTEGER "
-    "B ::= INTEGER (-128..127) "
-    "C ::= INTEGER (-32768..32767) "
-    "D ::= INTEGER (-2147483648..2147483647) "
-    "E ::= INTEGER (-9223372036854775808..9223372036854775807) "
-    "F ::= INTEGER (0..255) "
-    "G ::= INTEGER (0..65535) "
-    "H ::= INTEGER (0..4294967295) "
-    "I ::= INTEGER (0..18446744073709551615) "
-    "J ::= INTEGER (0..18446744073709551616) "
-    "K ::= INTEGER (1..MAX) "
-    "L ::= INTEGER (MIN..0) "
-    "END"
-)
-
-# (asn1tools type, value, scapy encoder callable)
+# (type name, value, scapy encoder callable, reference encoding)
 INTEGER_VECTORS = [
-    ("A", 0, lambda v: OERcodec_INTEGER.enc(v)),
-    ("A", 128, lambda v: OERcodec_INTEGER.enc(v)),
-    ("A", 100000, lambda v: OERcodec_INTEGER.enc(v)),
-    ("A", -255, lambda v: OERcodec_INTEGER.enc(v)),
-    ("A", -1234567, lambda v: OERcodec_INTEGER.enc(v)),
-    ("B", -2, lambda v: OERcodec_INTEGER.enc(v, size_len=1)),
-    ("C", -2, lambda v: OERcodec_INTEGER.enc(v, size_len=2)),
-    ("D", -2, lambda v: OERcodec_INTEGER.enc(v, size_len=4)),
-    ("E", -2, lambda v: OERcodec_INTEGER.enc(v, size_len=8)),
-    ("F", 128, lambda v: OERcodec_INTEGER.enc(v, size_len=1)),
-    ("G", 128, lambda v: OERcodec_INTEGER.enc(v, size_len=2)),
-    ("G", 1000, lambda v: OERcodec_INTEGER.enc(v, size_len=2)),
-    ("H", 128, lambda v: OERcodec_INTEGER.enc(v, size_len=4)),
-    ("I", 128, lambda v: OERcodec_INTEGER.enc(v, size_len=8)),
-    ("B", 1, lambda v: OERcodec_INTEGER.enc(v, size_len=1)),
-    ("K", 1, lambda v: OER_unsigned_integer_enc(v)),
-    ("K", 128, lambda v: OER_unsigned_integer_enc(v)),
-    ("L", -128, lambda v: OER_signed_integer_enc(v)),
+    ("A", 0, lambda v: OERcodec_INTEGER.enc(v), b"\x01\x00"),
+    ("A", 128, lambda v: OERcodec_INTEGER.enc(v), b"\x02\x00\x80"),
+    ("A", 100000, lambda v: OERcodec_INTEGER.enc(v), b"\x03\x01\x86\xa0"),
+    ("A", -255, lambda v: OERcodec_INTEGER.enc(v), b"\x02\xff\x01"),
+    ("A", -1234567, lambda v: OERcodec_INTEGER.enc(v), b"\x03\xed)y"),
+    ("B", -2, lambda v: OERcodec_INTEGER.enc(v, size_len=1), b"\xfe"),
+    ("C", -2, lambda v: OERcodec_INTEGER.enc(v, size_len=2), b"\xff\xfe"),
+    ("D", -2, lambda v: OERcodec_INTEGER.enc(v, size_len=4), b"\xff\xff\xff\xfe"),
+    (
+        "E",
+        -2,
+        lambda v: OERcodec_INTEGER.enc(v, size_len=8),
+        b"\xff\xff\xff\xff\xff\xff\xff\xfe",
+    ),
+    ("F", 128, lambda v: OERcodec_INTEGER.enc(v, size_len=1), b"\x80"),
+    ("G", 128, lambda v: OERcodec_INTEGER.enc(v, size_len=2), b"\x00\x80"),
+    ("G", 1000, lambda v: OERcodec_INTEGER.enc(v, size_len=2), b"\x03\xe8"),
+    ("H", 128, lambda v: OERcodec_INTEGER.enc(v, size_len=4), b"\x00\x00\x00\x80"),
+    (
+        "I",
+        128,
+        lambda v: OERcodec_INTEGER.enc(v, size_len=8),
+        b"\x00\x00\x00\x00\x00\x00\x00\x80",
+    ),
+    ("B", 1, lambda v: OERcodec_INTEGER.enc(v, size_len=1), b"\x01"),
+    ("K", 1, lambda v: OER_unsigned_integer_enc(v), b"\x01\x01"),
+    ("K", 128, lambda v: OER_unsigned_integer_enc(v), b"\x01\x80"),
+    ("L", -128, lambda v: OER_signed_integer_enc(v), b"\x01\x80"),
 ]
 
 BOOLEAN_VECTORS = [
-    (True, lambda v: OERcodec_BOOLEAN.enc(1 if v else 0)),
-    (False, lambda v: OERcodec_BOOLEAN.enc(1 if v else 0)),
+    (True, lambda v: OERcodec_BOOLEAN.enc(1 if v else 0), b"\xff"),
+    (False, lambda v: OERcodec_BOOLEAN.enc(1 if v else 0), b"\x00"),
 ]
 
 ENUMERATED_VECTORS = [
-    ("A ::= ENUMERATED { a(1) }", "A", "a", 1),
-    ("B ::= ENUMERATED { a(128) }", "B", "a", 128),
-    ("C ::= ENUMERATED { a(0), b(127) }", "C", "a", 0),
-    ("C ::= ENUMERATED { a(0), b(127) }", "C", "b", 127),
-    ("E ::= ENUMERATED { a(-1), b(1234) }", "E", "a", -1),
+    ("A", "a", 1, b"\x01"),
+    ("B", "a", 128, b"\x82\x00\x80"),
+    ("C", "a", 0, b"\x00"),
+    ("C", "b", 127, b"\x7f"),
+    ("E", "a", -1, b"\x81\xff"),
 ]
 
 OID_VECTORS = [
-    ("1.2", lambda v: OERcodec_OID.enc(v)),
-    ("1.2.3321", lambda v: OERcodec_OID.enc(v)),
+    ("1.2", lambda v: OERcodec_OID.enc(v), b"\x01*"),
+    ("1.2.3321", lambda v: OERcodec_OID.enc(v), b"\x03*\x99y"),
 ]
 
 OCTET_STRING_VECTORS = [
-    (b"\x12\x34", 0),
-    (b"\x12\x34\x56", 3),
+    (b"\x12\x34", 0, b"\x02\x124"),
+    (b"\x12\x34\x56", 3, b"\x124V"),
 ]
 
 BIT_STRING_VECTORS = [
-    # (asn1 value, scapy bit string)
-    ((b"\x40", 4), "0100"),
-    ((b"\x41", 8), "01000001"),
+    ("0100", b"\x02\x04@"),
+    ("01000001", b"\x02\x00A"),
 ]
 
-
-def require_asn1tools():
-    # type: () -> bool
-    """Return True if asn1tools is available for interoperability tests."""
-    return HAS_ASN1TOOLS
-
-
-def _compile(spec_body):
-    # type: (str) -> Any
-    assert asn1tools is not None
-    spec = "Foo DEFINITIONS AUTOMATIC TAGS ::= BEGIN %s END" % spec_body
-    return asn1tools.compile_string(spec, "oer")
-
-
-def _assert_encode_match(spec_body, type_name, value, scapy_enc):
-    # type: (str, str, Any, Callable[..., bytes]) -> None
-    compiled = _compile(spec_body)
-    expected = compiled.encode(type_name, value)
-    got = scapy_enc(value)
-    assert got == expected, (
-        "OER encode mismatch for %s=%r: asn1tools=%r scapy=%r" %
-        (type_name, value, expected, got)
-    )
-
-
-def _assert_decode_match(type_name, encoded, scapy_dec, expected_value):
-    # type: (str, bytes, Callable[[bytes], Tuple[Any, bytes]], Any) -> None
-    obj, remain = scapy_dec(encoded)
-    assert remain == b"", "unexpected remainder after decode of %s" % type_name
-    assert obj.val == expected_value, (
-        "OER decode mismatch for %s: got %r expected %r" %
-        (type_name, obj.val, expected_value)
-    )
+# (type name, value, reference encoding)
+SCAPY_DECODE_VECTORS = [
+    ("A", 42, b"\x01*"),
+    ("F", 200, b"\xc8"),
+    ("B", -99, b"\x9d"),
+]
 
 
 def check_primitive_interop():
     # type: () -> bool
-    """Compare Scapy OER primitives against asn1tools. Returns True on success."""
-    if not HAS_ASN1TOOLS:
-        return True
-
-    compiled = asn1tools.compile_string(ASN1TOOLS_INTEGER_SPEC, "oer")
-    for type_name, value, enc in INTEGER_VECTORS:
-        expected = compiled.encode(type_name, value)
+    """Compare Scapy OER primitives against reference encodings."""
+    for type_name, value, enc, expected in INTEGER_VECTORS:
         got = enc(value)
         assert got == expected, (
-            "integer %s=%r: asn1tools=%r scapy=%r" %
+            "integer %s=%r: reference=%r scapy=%r" %
             (type_name, value, expected, got)
         )
         if type_name == "A":
             dec, remain = OERcodec_INTEGER.do_dec(got)
             assert remain == b"" and dec.val == value
 
-    bool_spec = _compile("A ::= BOOLEAN")
-    for value, enc in BOOLEAN_VECTORS:
-        expected = bool_spec.encode("A", value)
+    for value, enc, expected in BOOLEAN_VECTORS:
         got = enc(value)
         assert got == expected
         dec, remain = OERcodec_BOOLEAN.do_dec(got)
         assert remain == b"" and dec.val == (1 if value else 0)
 
-    _assert_encode_match("A ::= NULL", "A", None, lambda _: OERcodec_NULL.enc(None))
+    got = OERcodec_NULL.enc(None)
+    assert got == b""
 
-    for spec_body, type_name, enum_name, enum_val in ENUMERATED_VECTORS:
-        compiled = _compile(spec_body)
-        expected = compiled.encode(type_name, enum_name)
+    for type_name, _enum_name, enum_val, expected in ENUMERATED_VECTORS:
         got = OERcodec_ENUMERATED.enc(enum_val)
         assert got == expected
         dec, remain = OERcodec_ENUMERATED.do_dec(got)
         assert remain == b"" and dec.val == enum_val
 
-    oid_spec = _compile("A ::= OBJECT IDENTIFIER")
-    for oid, enc in OID_VECTORS:
-        expected = oid_spec.encode("A", oid)
+    for oid, enc, expected in OID_VECTORS:
         got = enc(oid)
         assert got == expected
         dec, remain = OERcodec_OID.do_dec(got)
         assert remain == b"" and dec.val == oid
 
-    octet_spec = _compile(
-        "A ::= OCTET STRING\nB ::= OCTET STRING (SIZE (3))"
-    )
-    for data, fixed_size in OCTET_STRING_VECTORS:
-        type_name = "B" if fixed_size else "A"
-        expected = octet_spec.encode(type_name, data)
+    for data, fixed_size, expected in OCTET_STRING_VECTORS:
         got = OERcodec_STRING.enc(data, size_len=fixed_size or 0)
         assert got == expected
         dec, remain = OERcodec_STRING.do_dec(got, size_len=fixed_size or 0)
         assert remain == b"" and dec.val == data
 
-    bit_spec = _compile("A ::= BIT STRING")
-    for (data, nbits), bitstr in BIT_STRING_VECTORS:
-        expected = bit_spec.encode("A", (data, nbits))
+    for bitstr, expected in BIT_STRING_VECTORS:
         got = OERcodec_BIT_STRING.enc(bitstr)
         assert got == expected
         dec, remain = OERcodec_BIT_STRING.do_dec(got)
@@ -206,26 +138,23 @@ def check_primitive_interop():
     return True
 
 
-def check_asn1tools_decode_scapy_encode():
+def check_scapy_encode_reference_decode():
     # type: () -> bool
-    """Encode with Scapy, decode with asn1tools."""
-    if not HAS_ASN1TOOLS:
-        return True
-
-    compiled = asn1tools.compile_string(ASN1TOOLS_INTEGER_SPEC, "oer")
-    samples = [("A", 42), ("F", 200), ("B", -99)]
-    for type_name, value in samples:
-        encoded = {
-            "A": OERcodec_INTEGER.enc,
-            "F": lambda v: OERcodec_INTEGER.enc(v, size_len=1),
-            "B": lambda v: OERcodec_INTEGER.enc(v, size_len=1),
-        }[type_name](value)
-        decoded = compiled.decode(type_name, encoded)
-        assert decoded == value
-
-    bool_spec = _compile("A ::= BOOLEAN")
+    """Decode reference encodings with Scapy."""
+    for type_name, value, encoded in SCAPY_DECODE_VECTORS:
+        if type_name == "A":
+            dec, remain = OERcodec_INTEGER.do_dec(encoded)
+        elif type_name == "F":
+            dec, remain = OERcodec_INTEGER.do_dec(
+                encoded, size_len=1, oer_unsigned=True,
+            )
+        else:
+            dec, remain = OERcodec_INTEGER.do_dec(encoded, size_len=1)
+        assert remain == b"" and dec.val == value
+
     for val in [0, 1]:
         encoded = OERcodec_BOOLEAN.enc(val)
-        assert bool_spec.decode("A", encoded) == bool(val)
+        dec, remain = OERcodec_BOOLEAN.do_dec(encoded)
+        assert remain == b"" and dec.val == val
 
     return True