diff --git a/pcapkit/protocols/internet/hip.py b/pcapkit/protocols/internet/hip.py index 98b3f5651f..89a5d1bd0a 100644 --- a/pcapkit/protocols/internet/hip.py +++ b/pcapkit/protocols/internet/hip.py @@ -1236,7 +1236,7 @@ def _read_param_ack(self, schema: 'Schema_ACKParameter', *, version: 'int', # p ) return ack - def _read_param_dh_group_list(self, schema: 'Schema_DHGroupListParameter', *, version: 'int', # pylint: disable=unused-argument + def _read_param_dh_group_list(self, schema: 'Schema_DHGroupListParameter', *, version: 'int', options: 'Parameter') -> 'Data_DHGroupListParameter': # pylint: disable=unused-argument """Read HIP ``DH_GROUP_LIST`` parameter. @@ -1262,7 +1262,13 @@ def _read_param_dh_group_list(self, schema: 'Schema_DHGroupListParameter', *, ve Returns: Parsed parameter data. + Raises: + ProtocolError: The parameter is **NOT** supported in HIPv1. + """ + if version == 1: + raise ProtocolError(f'HIPv{version}: [ParamNo {schema.type}] invalid parameter') + dh_group_list = Data_DHGroupListParameter( type=schema.type, critical=bool(schema.type & 0b1), @@ -1380,9 +1386,12 @@ def _read_param_hip_cipher(self, schema: 'Schema_HIPCipherParameter', *, version Parsed parameter data. Raises: - ProtocolError: If ``schema.len`` is **NOT** a ``2`` modulo. + ProtocolError: If the parameter is used in HIPv1, or ``schema.len`` is + **NOT** a ``2`` modulo. """ + if version == 1: + raise ProtocolError(f'HIPv{version}: [ParamNo {schema.type}] invalid parameter') if schema.len % 2 != 0: raise ProtocolError(f'HIPv{version}: [ParamNo {schema.type}] invalid format') @@ -1596,7 +1605,7 @@ def _read_param_host_id(self, schema: 'Schema_HostIDParameter', *, version: 'int ) return host_id - def _read_param_hit_suite_list(self, schema: 'Schema_HITSuiteListParameter', *, version: 'int', # pylint: disable=unused-argument + def _read_param_hit_suite_list(self, schema: 'Schema_HITSuiteListParameter', *, version: 'int', options: 'Parameter') -> 'Data_HITSuiteListParameter': # pylint: disable=unused-argument """Read HIP ``HIT_SUITE_LIST`` parameter. @@ -1622,7 +1631,13 @@ def _read_param_hit_suite_list(self, schema: 'Schema_HITSuiteListParameter', *, Returns: Parsed parameter data. + Raises: + ProtocolError: The parameter is **NOT** supported in HIPv1. + """ + if version == 1: + raise ProtocolError(f'HIPv{version}: [ParamNo {schema.type}] invalid parameter') + hit_suite_list = Data_HITSuiteListParameter( type=schema.type, critical=bool(schema.type & 0b1), @@ -2005,9 +2020,12 @@ def _read_param_transport_format_list(self, schema: 'Schema_TransportFormatListP Parsed parameter data. Raises: - ProtocolError: If ``schema.len`` is **NOT** ``2`` modulo. + ProtocolError: If the parameter is used in HIPv1, or ``schema.len`` is + **NOT** ``2`` modulo. """ + if version == 1: + raise ProtocolError(f'HIPv{version}: [ParamNo {schema.type}] invalid parameter') if schema.len % 2 != 0: raise ProtocolError(f'HIPv{version}: [ParamNo {schema.type}] invalid format') @@ -3512,7 +3530,13 @@ def _make_param_dh_group_list(self, code: 'Enum_Parameter', param: 'Optional[Dat Returns: HIP parameter schema. + Raises: + ProtocolError: The parameter is **NOT** supported in HIPv1. + """ + if version == 1: + raise ProtocolError(f'HIPv{version}: [ParamNo {code}] invalid parameter') + if param is not None: group_id = cast('list[Enum_Group]', param.group_id) else: @@ -3634,7 +3658,13 @@ def _make_param_hip_cipher(self, code: 'Enum_Parameter', param: 'Optional[Data_H Returns: HIP parameter schema. + Raises: + ProtocolError: The parameter is **NOT** supported in HIPv1. + """ + if version == 1: + raise ProtocolError(f'HIPv{version}: [ParamNo {code}] invalid parameter') + if param is not None: cipher_id = cast('list[Enum_Cipher]', param.cipher_id) else: @@ -3917,7 +3947,13 @@ def _make_param_hit_suite_list(self, code: 'Enum_Parameter', param: 'Optional[Da Returns: HIP parameter schema. + Raises: + ProtocolError: The parameter is **NOT** supported in HIPv1. + """ + if version == 1: + raise ProtocolError(f'HIPv{version}: [ParamNo {code}] invalid parameter') + if param is not None: suite_id = cast('list[Enum_HITSuite]', param.suite_id) else: @@ -4339,7 +4375,13 @@ def _make_param_transport_format_list(self, code: 'Enum_Parameter', param: 'Opti Returns: HIP parameter schema. + Raises: + ProtocolError: The parameter is **NOT** supported in HIPv1. + """ + if version == 1: + raise ProtocolError(f'HIPv{version}: [ParamNo {code}] invalid parameter') + if param is not None: tf_type = cast('list[Enum_Parameter]', param.tf_type) else: diff --git a/tests/protocols/internet/test_hip_v2_only_parameters_unit.py b/tests/protocols/internet/test_hip_v2_only_parameters_unit.py new file mode 100644 index 0000000000..d2d9f4c883 --- /dev/null +++ b/tests/protocols/internet/test_hip_v2_only_parameters_unit.py @@ -0,0 +1,85 @@ +# -*- coding: utf-8 -*- +"""HIP rejects the HIPv2-only list parameters inside a HIPv1 packet. + +GitHub issue #1133. :rfc:`7401` introduces ``DH_GROUP_LIST`` (511), +``HIP_CIPHER`` (579), ``HIT_SUITE_LIST`` (715) and ``TRANSPORT_FORMAT_LIST`` +(2049); :rfc:`5201` has none of them. All four built and parsed back at +version 1. They now raise :class:`~pcapkit.utilities.exceptions.ProtocolError` +on both sides, as ``R1_Counter`` does for the opposite mismatch. +""" +from __future__ import annotations + +import importlib.util +import unittest + +from tests._support import reimport_once_per_class + +RUNTIME_DEPS = ('tbtrim', 'aenum', 'chardet', 'dictdumper') +HAS_RUNTIME = all(importlib.util.find_spec(name) is not None for name in RUNTIME_DEPS) + +#: Header fields shared by every HIP packet built here. +HIP_BASE = { + 'next': 6, 'packet': 1, 'checksum': b'\x00\x00', + 'controls_anonymous': False, 'shit': 0, 'rhit': 0, 'payload': b'', +} + + +@unittest.skipUnless(HAS_RUNTIME, 'runtime dependencies not installed') +class HIPv2OnlyParameterTests(unittest.TestCase): + """The four :rfc:`7401` list parameters, at HIP versions 1 and 2.""" + + def setUp(self) -> None: + reimport_once_per_class(self) + + def _cases(self) -> 'dict[object, dict[str, object]]': + """Map each HIPv2-only parameter code to the keywords that build it.""" + from pcapkit.const.hip.parameter import Parameter + + return { + Parameter.DH_GROUP_LIST: {'groups': [1]}, + Parameter.HIP_CIPHER: {'ciphers': [1]}, + Parameter.HIT_SUITE_LIST: {'suites': [1]}, + Parameter.TRANSPORT_FORMAT_LIST: {'formats': [Parameter.ESP_INFO]}, + } + + def _build(self, code: 'object', kwargs: 'dict[str, object]', version: 'int') -> 'bytes': + from pcapkit.protocols.internet.hip import HIP + + return HIP(parameters=[(code, kwargs)], extension=True, + version=version, **HIP_BASE).data + + def test_building_at_version_1_raises(self) -> None: + from pcapkit.utilities.exceptions import ProtocolError + + for code, kwargs in self._cases().items(): + with self.subTest(code=code): + with self.assertRaisesRegex(ProtocolError, rf'HIPv1: \[ParamNo {code}\] invalid parameter'): + self._build(code, kwargs, 1) + + def test_parsing_at_version_1_raises(self) -> None: + from pcapkit.protocols.internet.hip import HIP + from pcapkit.utilities.exceptions import ProtocolError + + for code, kwargs in self._cases().items(): + with self.subTest(code=code): + # Build at version 2, then rewrite the 4-bit Version field + # (the high nibble of octet 3) to 1. + octets = bytearray(self._build(code, kwargs, 2)) + octets[3] = (octets[3] & 0x0F) | 0x10 + with self.assertRaisesRegex(ProtocolError, rf'HIPv1: \[ParamNo {code}\] invalid parameter'): + HIP(bytes(octets), len(octets), extension=True) + + def test_version_2_still_round_trips(self) -> None: + from pcapkit.protocols.internet.hip import HIP + + for code, kwargs in self._cases().items(): + with self.subTest(code=code): + octets = self._build(code, kwargs, 2) + parsed = HIP(octets, len(octets), extension=True) + self.assertEqual(parsed.info.version, 2) + codes = [int(key) for key in parsed.info.parameters] + self.assertEqual(codes, [int(code)]) # type: ignore[call-overload] + + +if __name__ == '__main__': + unittest.main()