@@ -347,6 +347,106 @@ class _IPInterfaceField(_IPField[_IT]):
     """
 
 
+class _RawMaskIPv4Interface(ipaddress.IPv4Interface):
+    """IPv4 interface whose mask is not a contiguous netmask.
+
+    Args:
+        address: Dotted address and dotted mask, as ``'a.b.c.d/m.m.m.m'``.
+
+    :class:`ipaddress.IPv4Interface` can only hold a prefix length, so it
+    reads a hostmask-shaped mask such as ``0.0.0.255`` as ``/24`` and rejects
+    a mask such as ``255.0.255.0``. This class keeps the mask octets as given
+    in :attr:`netmask`, so :meth:`IPv4InterfaceField.pre_process` writes them
+    back unchanged. :func:`str`, :func:`repr` and :mod:`pickle` use the
+    dotted ``address/mask`` form, which the field also packs octet for octet.
+
+    Equality and ordering use the mask too. An instance sorts as the stdlib
+    sorts ``address/32``, then by mask, so the order stays total when mixed
+    with :class:`ipaddress.IPv4Interface` values.
+
+    Such a mask has no prefix length, so :attr:`network`, :attr:`with_prefixlen`
+    and the prefix length all describe the address alone (``/32``); only
+    :attr:`netmask`, :attr:`hostmask`, :attr:`with_netmask` and
+    :attr:`with_hostmask` carry the mask.
+
+    """
+
+    def __init__(self, address: 'str') -> 'None':
+        addr, _, mask = address.partition('/')
+        super().__init__(addr)
+        self.netmask = ipaddress.IPv4Address(mask)
+
+    @property
+    def hostmask(self) -> 'IPv4Address':
+        """Bitwise inverse of :attr:`netmask`."""
+        return ipaddress.IPv4Address(int(self.netmask) ^ 0xFFFFFFFF)
+
+    def __str__(self) -> 'str':
+        return f'{self.ip}/{self.netmask}'
+
+    def __eq__(self, other: 'object') -> 'bool':
+        if not isinstance(other, ipaddress.IPv4Interface):
+            return NotImplemented
+        return self.ip == other.ip and self.netmask == other.netmask
+
+    def __hash__(self) -> 'int':
+        return hash((int(self.ip), int(self.netmask)))
+
+    def __lt__(self, other: 'Any') -> 'bool':
+        if not isinstance(other, ipaddress.IPv4Interface):
+            return ipaddress.IPv4Interface.__lt__(self, other)
+        return _interface_order(self) < _interface_order(other)
+
+    def __le__(self, other: 'Any') -> 'bool':
+        if not isinstance(other, ipaddress.IPv4Interface):
+            return ipaddress.IPv4Interface.__le__(self, other)
+        return _interface_order(self) <= _interface_order(other)
+
+    def __gt__(self, other: 'Any') -> 'bool':
+        if not isinstance(other, ipaddress.IPv4Interface):
+            return ipaddress.IPv4Interface.__gt__(self, other)
+        return _interface_order(self) > _interface_order(other)
+
+    def __ge__(self, other: 'Any') -> 'bool':
+        if not isinstance(other, ipaddress.IPv4Interface):
+            return ipaddress.IPv4Interface.__ge__(self, other)
+        return _interface_order(self) >= _interface_order(other)
+
+
+def _is_netmask(mask: 'IPv4Address') -> 'bool':
+    """Tell whether ``mask`` is a contiguous netmask (leading ones, then zeros).
+
+    Args:
+        mask: Dotted mask.
+
+    Returns:
+        :data:`True` for ``0.0.0.0`` through ``255.255.255.255`` with no gap
+        in the ones, :data:`False` otherwise.
+
+    """
+    inverse = int(mask) ^ 0xFFFFFFFF
+    return not inverse & (inverse + 1)
+
+
+def _interface_order(value: 'IPv4Interface') -> 'tuple[int, int, int, int]':
+    """Sort key for an IPv4 interface, consistent with ``==``.
+
+    Args:
+        value: IPv4 interface, either from the stdlib or a
+            :class:`_RawMaskIPv4Interface`.
+
+    Returns:
+        The stdlib order (network address, netmask, address), with a third
+        element that is ``0`` for a stdlib interface and ``1 + mask`` for a
+        :class:`_RawMaskIPv4Interface`, whose stdlib network is
+        ``address/32``.
+
+    """
+    if isinstance(value, _RawMaskIPv4Interface):
+        return int(value.ip), 0xFFFFFFFF, 1 + int(value.netmask), int(value.ip)
+    return int(value.network.network_address), int(value.network.netmask), 0, int(value.ip)
+
+
 class IPv4InterfaceField(_IPInterfaceField[ipaddress.IPv4Interface]):
     """IPv4 interface value for protocol fields.
 
@@ -383,14 +483,30 @@ def pre_process(self, value: 'IPv4Interface | bytes | int | str', packet: 'dict[
                 :func:`_reject_bool`), is not a valid IP interface, or is the
                 wrong IP version for this field.
 
+        Notes:
+            A string with a dotted mask that is not a contiguous netmask,
+            such as ``'10.0.0.1/0.0.0.255'``, packs those mask octets as
+            given -- the form :func:`str` gives a
+            :class:`_RawMaskIPv4Interface` -- where :func:`ipaddress.ip_interface`
+            would read a hostmask or reject the mask. Any other string goes
+            through :func:`ipaddress.ip_interface`.
+
         """
         _reject_bool(value, 'invalid IP interface')
 
         if isinstance(value, ipaddress.IPv4Interface):
             val = value
         else:
-            with _reraise_as_field_value_error('invalid IP interface'):
-                parsed = ipaddress.ip_interface(value)
+            parsed = None  # type: Optional[IPv4Interface | IPv6Interface]
+            if isinstance(value, str) and '.' in value.partition('/')[2]:
+                # a dotted mask that is not a netmask is kept as given, as
+                # in :meth:`post_process`, rather than read as a hostmask
+                with _reraise_as_field_value_error('invalid IP interface'):
+                    if not _is_netmask(ipaddress.IPv4Address(value.partition('/')[2])):
+                        parsed = _RawMaskIPv4Interface(value)
+            if parsed is None:
+                with _reraise_as_field_value_error('invalid IP interface'):
+                    parsed = ipaddress.ip_interface(value)
             if not isinstance(parsed, ipaddress.IPv4Interface):
                 raise FieldValueError(f'IP version mismatch: {parsed.version} != {self.version}')
             val = parsed
@@ -410,26 +526,32 @@ def post_process(self, value: 'bytes', packet: 'dict[str, Any]') -> 'IPv4Interfa
             Processed field value.
 
         Raises:
-            FieldValueError: If the trailing four octets are not a valid
-                dotted netmask, or if the resulting interface is the wrong IP
-                version for this field. The leading four octets cannot
-                actually fail here -- they are always exactly 4 octets, fixed
-                by this field's length, and any such octet string is a valid
-                address -- but the conversion is still wrapped for
-                consistency with the rest of this module.
+            FieldValueError: If the resulting interface is the wrong IP
+                version for this field. The eight octets cannot actually fail
+                to convert here -- they are always exactly 8 octets, fixed by
+                this field's length, any four octets are a valid address, and
+                a mask that is not a netmask is kept as given -- but the
+                conversion is still wrapped for consistency with the rest of
+                this module.
 
         Notes:
             The trailing four octets are a dotted netmask, as written by
             :meth:`pre_process` -- not a prefix length as in
-            :meth:`IPv6InterfaceField.post_process`.
+            :meth:`IPv6InterfaceField.post_process`. When they are not a
+            contiguous netmask, the value is a :class:`_RawMaskIPv4Interface`
+            that keeps them as given, rather than an interface the stdlib
+            would reinterpret (``0.0.0.255`` as the hostmask of ``/24``).
 
         """
         with _reraise_as_field_value_error('invalid IPv4 address'):
             ip = ipaddress.IPv4Address(value[:4])
             mask = ipaddress.IPv4Address(value[4:])
 
         with _reraise_as_field_value_error('invalid IPv4 interface'):
-            val = ipaddress.ip_interface(f'{ip}/{mask}')
+            if _is_netmask(mask):
+                val = ipaddress.ip_interface(f'{ip}/{mask}')
+            else:
+                val = _RawMaskIPv4Interface(f'{ip}/{mask}')
         if not isinstance(val, ipaddress.IPv4Interface):
             raise FieldValueError(f'IP version mismatch: {val.version} != {self.version}')
         return val
 
@@ -497,6 +497,18 @@ def __eq__(self, other: 'Any') -> 'bool':
 
     __hash__ = None  # type: ignore[assignment]
 
+    def deepcopy(self, memo: 'Optional[dict]' = None) -> 'OrderedMultiDict[_KT, _VT]':
+        """Return a deep copy of this object.
+
+        Notes:
+            :meth:`MultiDict.deepcopy` rebuilds from :meth:`to_dict` with
+            ``flat=False``, which groups the values by key. This rebuilds from
+            ``items(multi=True)`` instead, so the copy keeps the insertion
+            order of interleaved keys. :meth:`__deepcopy__` reaches it too.
+
+        """
+        return self.__class__(copy.deepcopy(list(self.items(multi=True)), memo=memo))
+
     def __reduce_ex__(self, protocol: 'SupportsIndex') -> 'tuple[type, tuple[list[tuple[_KT, _VT]]]]':
         return type(self), (list(self.items(multi=True)),)
 
 
@@ -606,30 +606,24 @@ def test_switch_backed_address_makers_reject_a_bool(self) -> None:
                 locator_set=[{'ip': int(True)}]).pack().hex(),
             '00c1001800000400000000000000000000000000000000000000000100000000')
 
-    def test_ipv4_interface_post_process_rejects_a_non_contiguous_netmask(self) -> None:
-        """``IPv4InterfaceField.post_process`` builds
-        ``ipaddress.ip_interface(f'{ip}/{mask}')`` from wire bytes whose
-        trailing four octets are meant to be a dotted netmask. Unlike the
-        leading four octets (always exactly 4 octets, so always a valid
-        address), those trailing octets are not guaranteed to form a
-        *contiguous* netmask -- e.g. a capture with a malformed or corrupted
-        IPv4 interface option can carry ``0.255.0.255``, which
-        :func:`ipaddress.ip_interface` rejects with a bare
-        :exc:`~ipaddress.NetmaskValueError`. This is reachable through
-        :meth:`~pcapkit.corekit.fields.field.FieldBase.unpack` alone, with no
-        malformed-length input required, and must raise :exc:`FieldValueError`
-        instead.
+    def test_ipv4_interface_post_process_keeps_a_non_contiguous_netmask(self) -> None:
+        """``IPv4InterfaceField.post_process`` reads wire bytes whose trailing
+        four octets are meant to be a dotted netmask. Those octets are not
+        guaranteed to form a *contiguous* netmask -- e.g. a capture with a
+        malformed or corrupted IPv4 interface option can carry
+        ``0.255.0.255``, which :func:`ipaddress.ip_interface` rejects. The
+        field keeps such a mask as given, so the value packs back to the same
+        octets (c.f. :issue:`1294`).
         """
         from pcapkit.corekit.fields.ipaddress import IPv4InterfaceField
-        from pcapkit.utilities.exceptions import BaseError, FieldValueError
 
         field = IPv4InterfaceField()
         raw = ipaddress.IPv4Address('1.2.3.4').packed + bytes([0, 255, 0, 255])
 
-        with self.assertRaises(FieldValueError) as context:
-            field.unpack(raw, {})
-        self.assertIsInstance(context.exception, BaseError)
-        self.assertIn('0.255.0.255', str(context.exception))
+        value = field.unpack(raw, {})
+        self.assertIsInstance(value, ipaddress.IPv4Interface)
+        self.assertEqual(value.netmask, ipaddress.IPv4Address('0.255.0.255'))
+        self.assertEqual(field.pack(value, {}), raw)
 
 
 if __name__ == '__main__':
 
@@ -0,0 +1,123 @@
+# -*- coding: utf-8 -*-
+"""IPv4 interface fields keep the mask octets they read.
+
+GitHub issue #1294: :meth:`IPv4InterfaceField.post_process
+<pcapkit.corekit.fields.ipaddress.IPv4InterfaceField.post_process>` built the
+value with :func:`ipaddress.ip_interface`, which reads a hostmask-shaped mask
+such as ``0.0.0.255`` as ``/24``. The field then packed ``255.255.255.0``, so
+a pcapng ``if_IPv4addr`` option did not rebuild byte for byte.
+
+Every case builds its own octets in memory and reads no capture. Classes are
+imported inside each test, after
+:func:`~tests._support.reimport_once_per_class`, for the reason given in
+:mod:`tests.protocols.link.test_ethernet_mac_roundtrip_unit`.
+
+"""
+
+import copy
+import ipaddress
+import pickle
+import unittest
+
+from tests._support import reimport_once_per_class
+
+#: Address ``10.0.0.1`` followed by four mask octets.
+MASKS = {
+    'hostmask /24': '0a000001' '000000ff',
+    'hostmask /1': '0a000001' '7fffffff',
+    'non-contiguous': '0a000001' 'ff00ff00',
+    'netmask /24': '0a000001' 'ffffff00',
+    'netmask /0': '0a000001' '00000000',
+    'netmask /32': '0a000001' 'ffffffff',
+}
+
+
+class TestIPv4InterfaceMask(unittest.TestCase):
+    """Pin the mask octets of :class:`IPv4InterfaceField` across a round trip."""
+
+    def setUp(self) -> None:
+        reimport_once_per_class(self)
+
+    def test_unpack_then_pack_keeps_the_mask_octets(self) -> None:
+        from pcapkit.corekit.fields.ipaddress import IPv4InterfaceField
+
+        field = IPv4InterfaceField()
+        for name, hexstr in MASKS.items():
+            with self.subTest(mask=name):
+                raw = bytes.fromhex(hexstr)
+                value = field.unpack(raw, {})
+                self.assertIsInstance(value, ipaddress.IPv4Interface)
+                self.assertEqual(value.ip, ipaddress.IPv4Address('10.0.0.1'))
+                self.assertEqual(value.netmask.packed, raw[4:])
+                self.assertEqual(field.pack(value, {}), raw)
+
+    def test_string_form_of_a_parsed_value_packs_to_the_same_octets(self) -> None:
+        from pcapkit.corekit.fields.ipaddress import IPv4InterfaceField
+
+        field = IPv4InterfaceField()
+        for name, hexstr in MASKS.items():
+            with self.subTest(mask=name):
+                raw = bytes.fromhex(hexstr)
+                self.assertEqual(field.pack(str(field.unpack(raw, {})), {}), raw)
+
+    def test_prefix_and_netmask_strings_still_use_the_stdlib(self) -> None:
+        from pcapkit.corekit.fields.ipaddress import IPv4InterfaceField
+
+        field = IPv4InterfaceField()
+        for text in ('10.0.0.1/24', '10.0.0.1/255.255.255.0'):
+            with self.subTest(text=text):
+                self.assertEqual(field.pack(text, {}), bytes.fromhex(MASKS['netmask /24']))
+        self.assertEqual(field.pack('10.0.0.1', {}), bytes.fromhex(MASKS['netmask /32']))
+
+    def test_ordering_agrees_with_equality(self) -> None:
+        from pcapkit.corekit.fields.ipaddress import IPv4InterfaceField
+
+        field = IPv4InterfaceField()
+        values = [field.unpack(bytes.fromhex(hexstr), {}) for hexstr in MASKS.values()]
+        values += [field.unpack(bytes.fromhex('0a000002' '000000ff'), {}),
+                   ipaddress.IPv4Interface('10.0.0.5/8'), ipaddress.IPv4Interface('10.0.0.3/32')]
+        for a in values:
+            for b in values:
+                with self.subTest(a=str(a), b=str(b)):
+                    self.assertEqual([a < b, a == b, a > b].count(True), 1)
+                    self.assertEqual(a < b, b > a)
+                    self.assertEqual(a <= b, b >= a)
+                    self.assertEqual(a <= b, a < b or a == b)
+                    self.assertEqual(a >= b, a > b or a == b)
+                    for c in values:
+                        if a < b < c:
+                            self.assertLess(a, c)
+
+    def test_contiguous_netmask_stays_a_plain_interface(self) -> None:
+        from pcapkit.corekit.fields.ipaddress import IPv4InterfaceField
+
+        value = IPv4InterfaceField().unpack(bytes.fromhex(MASKS['netmask /24']), {})
+        self.assertIs(type(value), ipaddress.IPv4Interface)
+        self.assertEqual(value, ipaddress.IPv4Interface('10.0.0.1/24'))
+
+    def test_kept_mask_survives_copy_pickle_and_compares_by_mask(self) -> None:
+        from pcapkit.corekit.fields.ipaddress import IPv4InterfaceField
+
+        field = IPv4InterfaceField()
+        value = field.unpack(bytes.fromhex(MASKS['hostmask /24']), {})
+        self.assertEqual(str(value), '10.0.0.1/0.0.0.255')
+        self.assertEqual(value.hostmask, ipaddress.IPv4Address('255.255.255.0'))
+        for clone in (copy.copy(value), copy.deepcopy(value), pickle.loads(pickle.dumps(value))):
+            self.assertEqual(clone, value)
+            self.assertEqual(hash(clone), hash(value))
+            self.assertEqual(clone.netmask, value.netmask)
+        # the stdlib reading of the same octets is a different value
+        self.assertNotEqual(value, ipaddress.IPv4Interface('10.0.0.1/24'))
+        self.assertNotEqual(value, field.unpack(bytes.fromhex(MASKS['hostmask /1']), {}))
+
+    def test_pcapng_if_ipv4addr_option_rebuilds_byte_for_byte(self) -> None:
+        from pcapkit.protocols.schema.misc.pcapng import IF_IPv4AddrOption
+
+        option = bytes.fromhex('0400' '0800') + bytes.fromhex(MASKS['hostmask /24'])
+        schema = IF_IPv4AddrOption.unpack(option)
+        self.assertEqual(schema.interface.netmask, ipaddress.IPv4Address('0.0.0.255'))
+        self.assertEqual(schema.pack(), option)
+
+
+if __name__ == '__main__':
+    unittest.main()