netprotocols 1.0.1__tar.gz → 1.2.0__tar.gz

{netprotocols-1.0.1 → netprotocols-1.2.0}/ARCHITECTURE.md

@@ -115,8 +115,23 @@ flowchart LR
   I6 -->|58| IC6[ICMPv6]
   I6 -->|6| T
   I6 -->|17| U
+  I6 -->|0, 43, 44, 60| X[IPv6 extension headers]
+  X --> X
+  X -->|58| IC6
+  X -->|6| T
+  X -->|17| U
 ```
 
+IPv6 extension headers (Hop-by-Hop Options, Routing, Fragment,
+Destination Options) chain like any other protocol — each names what
+follows via `next_header` — and may stack. Two guardrails: the
+registry hands them out only inside an IPv6 chain (a garbage IPv4
+packet with `protocol=0` cannot conjure a Hop-by-Hop layer), and a
+Fragment header chains onward only when `fragment_offset == 0` — a
+non-first fragment carries a slice from the middle of the original
+payload, so no upper-layer header exists at its start. The same
+offset rule applies to fragmented IPv4.
+
 The numbers on the arrows are the wire values — EtherTypes out of
 Ethernet, IP protocol numbers out of IPv4/IPv6 — and they live in
 [`_enums.py`](src/netprotocols/_enums.py) as `EtherType` and
@@ -143,6 +158,26 @@ the graph acyclic: shared registries live in the dependency-free
 `_enums.py`, and `next_protocol()` mappings import their target
 classes *inside the function body*, at call time.
 
+## Port-based dispatch is best-effort
+
+The EtherType and IP-protocol registries dispatch on a single
+authoritative field. Application protocols break that model: they are
+identified by *port*, which is a heuristic — any service may run on any
+port, and the discriminator is split across the source and destination
+ports. `UDP.next_protocol()` therefore consults a well-known-port
+registry (`netprotocols.layer4._ports`), checking the destination port
+first (a request targets the server's port) and then the source port
+(a response comes from it). `DNS` is the first such protocol; a DNS
+message on UDP port 53 now decodes as a fourth layer.
+
+Because the guess can be wrong, the application class validates
+strictly on decode: a non-DNS datagram that happens to use port 53
+raises a `ProtocolError`, which the ordinary decode-error path absorbs
+(the chain keeps the layers it did decode and records the failure). So
+a mis-dispatch degrades to a diagnosed frame, never to garbage. Only
+UDP is wired this way for now — DNS over TCP carries a 2-byte length
+prefix (RFC 1035 §4.2.2) that needs separate handling.
+
 ## The encode side, and the round-trip guarantee
 
 Every class also works in reverse. Constructors take the friendly
@@ -159,10 +194,14 @@ Protocol.decode(bytes(header)) == header        # object → wire → object
 bytes(Protocol.decode(raw)) == raw[:header_len] # wire → object → wire
 ```
 
-One deliberate exception: **checksums are carried verbatim**. The
-library neither computes nor verifies them (yet — it's on the
-roadmap), which is exactly what you want when faithfully re-encoding
-captured traffic.
+One deliberate boundary: **decode and encode carry checksums
+verbatim** — exactly what you want when faithfully re-encoding
+captured traffic. Computing and verifying them is explicit, via
+`netprotocols.checksum`: `compute()`/`verify()` handle the IPv4 header
+checksum, ICMPv4, and TCP/UDP/ICMPv6 with their IPv4/IPv6
+pseudo-headers, and `Packet.with_checksums(payload)` fills a whole
+stack before sending. (The RFC 768 subtlety lives where it belongs:
+the `0x0000 → 0xFFFF` substitution applies to UDP alone.)
 
 `Packet` is the thin composition layer: it holds an ordered tuple of
 headers and `bytes(packet)` joins them, ready for a raw socket.
@@ -174,13 +213,24 @@ src/netprotocols/
 ├── __init__.py     public API re-exports, __version__
 ├── _base.py        Protocol ABC, decode contract, address helpers
 ├── _enums.py       EtherType, IPProtocol, ARPOperation (imports nothing)
-├── packet.py       Packet composition
+├── packet.py       Packet composition, with_checksums()
+├── checksum.py     RFC 1071: internet_checksum, compute, verify
 ├── layer2/         ethernet.py, arp.py
-├── layer3/         ip.py (IPv4 + IPv6), icmp.py (ICMPv4 + ICMPv6)
-├── layer4/         tcp.py, udp.py
+├── layer3/         ip.py (IPv4 + IPv6), icmp.py (ICMPv4 + ICMPv6),
+│                   igmp.py,
+│                   ipv6_ext.py (Hop-by-Hop, Routing, Fragment,
+│                   Destination Options)
+├── layer4/         tcp.py, udp.py, _ports.py (well-known-port registry)
+├── layer7/         dns.py
 └── utils/          validators (mac.py, ipv4.py), exceptions.py
 tests/              one file per protocol + test_contract.py
-                    (truncation, lying lengths, chain walks)
+                    (truncation, lying lengths, chain walks),
+                    test_corpus.py (invariants over the real-capture
+                    corpus in tests/fixtures/, 65 frames across 12
+                    scenarios — see its MANIFEST.md), test_checksum.py
+                    (corpus checksums recompute to wire values), and
+                    test_fuzz.py (hypothesis properties: decode never
+                    raises outside ProtocolError)
 ```
 
 Tooling: [uv](https://docs.astral.sh/uv/) manages the environment
@@ -202,12 +252,20 @@ the same:
    (raise `TruncatedHeaderError` when the buffer can't satisfy it) and
    materialize the variable part as `bytes`.
 3. **Implement `__bytes__()`.** Pack the same fields back; the
-   round-trip tests will hold you honest.
+   round-trip tests will hold you honest. When a payload is
+   self-referential — DNS names compress by pointing at earlier bytes,
+   so re-encoding a parsed record cannot reproduce the original — keep
+   that region as raw `bytes` and parse it through read-only accessors
+   that never re-encode. `bytes(decode(x)) == x` then holds by
+   construction (see `layer7/dns.py`).
 4. **Wire the chain.** The layer below decides when your class is
    next. For DNS that means UDP would implement `next_protocol()`
    consulting the ports. (For a new EtherType or IP protocol number,
-   add the value to `_enums.py` and one mapping entry in
-   `ethernet.py`/`ip.py`, using a deferred import.)
+   add the value to `_enums.py` — display name in lockstep, a test
+   enforces it — and one mapping entry in `ethernet.py`/`ip.py`, using
+   a deferred import. Numbers valid only inside an IPv6 chain follow
+   the extension headers' example: `_ip_protocol_class` hands them out
+   only when `ipv6=True`.)
 5. **Add display properties** for anything a human would want rendered
    (`flags_str`-style names, hex strings). Degrade gracefully on
    unknown values — return `"unknown (47)"`, never raise from a

{netprotocols-1.0.1 → netprotocols-1.2.0}/CHANGELOG.md

@@ -5,6 +5,51 @@ All notable changes to this project will be documented in this file.
 The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.1.0/),
 and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
+## [1.2.0] - 2026-08-30
+
+### Added
+- **IGMP** (`netprotocols.IGMP`, RFC 1112/2236/3376) — IPv4 multicast
+  group management, dispatched from IPv4 protocol 2. The common
+  four-byte header (type, max-response code, checksum) is decoded; the
+  `group_address` accessor reads the group for the message types that
+  carry one, and `netprotocols.checksum` gains an IGMP arm. v3
+  group-record parsing is a roadmap follow-up.
+- **DNS** (`netprotocols.DNS`, RFC 1035) — the first application-layer
+  protocol. The 12-byte header and flag bits are decoded; the four
+  message sections are kept raw with on-demand, read-only accessors
+  (`question_name`, `question_type`, `question_class`) that decompress
+  names safely (bounded pointer-following; malformed or looping names
+  raise `InvalidFieldError`, never hang). Round-trip stays byte-exact.
+- **Port-based dispatch** on UDP: `UDP.next_protocol()` reaches an
+  application protocol by well-known port (`netprotocols.layer4._ports`,
+  `{53: DNS}` for now), checked destination-then-source. Documented as
+  best-effort — a mis-dispatch degrades to the malformed-frame path.
+
+## [1.1.0] - 2026-08-29
+
+### Added
+- **IPv6 extension headers** (RFC 8200 §4.3-4.6): `IPv6HopByHopOptions`,
+  `IPv6Routing`, `IPv6Fragment`, `IPv6DestinationOptions`. The decode
+  chain now reaches ICMPv6/TCP/UDP behind them (MLD reports decode
+  fully). Extension headers dispatch only inside an IPv6 chain, and a
+  Fragment header chains onward only from the first fragment.
+- **Checksums** (`netprotocols.checksum`): `internet_checksum()`
+  (RFC 1071), `compute()`/`verify()` covering the IPv4 header checksum,
+  ICMPv4, and TCP/UDP/ICMPv6 with IPv4/IPv6 pseudo-headers, and
+  `Packet.with_checksums()` for filling a whole stack on encode. The
+  UDP-only zero substitution is confined to the UDP arm.
+- **Property-based fuzzing** of the decode path (hypothesis, dev-only):
+  decode() raises nothing outside `ProtocolError` for any input; the
+  chain walk never consumes past the frame; constrained round trips.
+- `IPProtocol` gains `HOPOPT`, `IPV6_ROUTE`, `IPV6_FRAG`,
+  `IPV6_DSTOPTS` with display names.
+
+### Development
+- The real-capture fixture corpus grew to 65 frames across 12
+  scenarios (MLD behind hop-by-hop, IPv6 fragment pairs); checksum
+  tests recompute every verifiable corpus frame to its captured wire
+  value.
+
 ## [1.0.1] - 2026-08-29
 
 ### Fixed

{netprotocols-1.0.1 → netprotocols-1.2.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: netprotocols
-Version: 1.0.1
+Version: 1.2.0
 Summary: Low-level implementations of common networking protocols
 Project-URL: Homepage, https://github.com/EONRaider/NETProtocols
 Project-URL: Repository, https://github.com/EONRaider/NETProtocols
@@ -67,11 +67,17 @@ Requires Python 3.12+. Fully typed (`py.typed`, mypy strict).
 | 2 | Ethernet II | `Ethernet` | IEEE 802.3 |
 | 2 | ARP | `ARP` | RFC 826, IPv4-over-Ethernet binding |
 | 3 | IPv4 | `IPv4` | RFC 791, IHL/options aware |
-| 3 | IPv6 | `IPv6` | RFC 8200, fixed header |
+| 3 | IPv6 | `IPv6` | RFC 8200 |
+| 3 | IPv6 Hop-by-Hop Options | `IPv6HopByHopOptions` | RFC 8200 §4.3 |
+| 3 | IPv6 Routing | `IPv6Routing` | RFC 8200 §4.4 |
+| 3 | IPv6 Fragment | `IPv6Fragment` | RFC 8200 §4.5, first-fragment chaining |
+| 3 | IPv6 Destination Options | `IPv6DestinationOptions` | RFC 8200 §4.6 |
 | 3 | ICMPv4 | `ICMPv4` | RFC 792, 8-byte header |
 | 3 | ICMPv6 | `ICMPv6` | RFC 4443, 8-byte header |
+| 3 | IGMP | `IGMP` | RFC 1112/2236/3376, IPv4 multicast management |
 | 4 | TCP | `TCP` | RFC 9293, data-offset/options aware |
 | 4 | UDP | `UDP` | RFC 768 |
+| 7 | DNS | `DNS` | RFC 1035, over UDP; header + on-demand name decompression |
 
 ## Decoding a captured frame
 
@@ -127,8 +133,9 @@ frame = Packet(
 raw = bytes(frame)  # ready for a raw socket
 ```
 
-Checksums are carried verbatim in both directions: the library neither
-computes nor verifies them (planned — see the roadmap).
+Checksums are computed and verified on request — never silently:
+`compute()`/`verify()` in `netprotocols.checksum`, and
+`Packet.with_checksums()` to fill a whole stack before sending.
 
 ## Display helpers
 
@@ -145,23 +152,26 @@ byte layout maps onto a dataclass, the decode contract, the
 `next_protocol()` chain, and a cookbook for adding a new protocol.
 
 This library is the engine behind
-[Packet-Sniffer](https://github.com/EONRaider/Packet-Sniffer), a
-network traffic monitor built on it.
+[RootWire](https://github.com/EONRaider/RootWire), a network traffic
+monitor built on it (formerly Packet-Sniffer).
 
 ## Roadmap
 
-- IPv6 extension headers (hop-by-hop, routing, fragment, destination
-  options) — today the decode chain ends at `IPv6` for traffic behind
-  them (e.g. MLD).
-- 802.1Q VLAN tags, DNS, DHCP, IGMP, GRE.
-- Checksum computation on encode and verification flags on decode.
-- Fuzzing of the decode path.
+- More protocols: 802.1Q VLAN tags, DHCP, GRE (DNS and IGMP shipped in 1.2).
+- Full DNS resource-record parsing (the header and question are decoded today; answer/authority/additional sections are kept raw).
+- IGMPv3 group-record parsing (the common header is decoded today; v3 report records are kept raw in the body).
+- Optional richer address accessors (`ipaddress` / EUI objects
+  alongside the `str` fields).
+- TLV parsing inside IPv6 extension-header options.
 
 ## Contributing
 
 Development uses [uv](https://docs.astral.sh/uv/): `uv sync`, then
 `uv run pytest`, `uv run mypy`, and `uv run ruff check` — all three are
-enforced by CI on Python 3.12–3.14. Start with
+enforced by CI on Python 3.12–3.14. The test suite is anchored by a
+65-frame corpus of real captured traffic
+([tests/fixtures/MANIFEST.md](tests/fixtures/MANIFEST.md)) plus
+property-based fuzzing of the decode path. Start with
 [ARCHITECTURE.md](ARCHITECTURE.md).
 
 ## License

{netprotocols-1.0.1 → netprotocols-1.2.0}/README.md

@@ -42,11 +42,17 @@ Requires Python 3.12+. Fully typed (`py.typed`, mypy strict).
 | 2 | Ethernet II | `Ethernet` | IEEE 802.3 |
 | 2 | ARP | `ARP` | RFC 826, IPv4-over-Ethernet binding |
 | 3 | IPv4 | `IPv4` | RFC 791, IHL/options aware |
-| 3 | IPv6 | `IPv6` | RFC 8200, fixed header |
+| 3 | IPv6 | `IPv6` | RFC 8200 |
+| 3 | IPv6 Hop-by-Hop Options | `IPv6HopByHopOptions` | RFC 8200 §4.3 |
+| 3 | IPv6 Routing | `IPv6Routing` | RFC 8200 §4.4 |
+| 3 | IPv6 Fragment | `IPv6Fragment` | RFC 8200 §4.5, first-fragment chaining |
+| 3 | IPv6 Destination Options | `IPv6DestinationOptions` | RFC 8200 §4.6 |
 | 3 | ICMPv4 | `ICMPv4` | RFC 792, 8-byte header |
 | 3 | ICMPv6 | `ICMPv6` | RFC 4443, 8-byte header |
+| 3 | IGMP | `IGMP` | RFC 1112/2236/3376, IPv4 multicast management |
 | 4 | TCP | `TCP` | RFC 9293, data-offset/options aware |
 | 4 | UDP | `UDP` | RFC 768 |
+| 7 | DNS | `DNS` | RFC 1035, over UDP; header + on-demand name decompression |
 
 ## Decoding a captured frame
 
@@ -102,8 +108,9 @@ frame = Packet(
 raw = bytes(frame)  # ready for a raw socket
 ```
 
-Checksums are carried verbatim in both directions: the library neither
-computes nor verifies them (planned — see the roadmap).
+Checksums are computed and verified on request — never silently:
+`compute()`/`verify()` in `netprotocols.checksum`, and
+`Packet.with_checksums()` to fill a whole stack before sending.
 
 ## Display helpers
 
@@ -120,23 +127,26 @@ byte layout maps onto a dataclass, the decode contract, the
 `next_protocol()` chain, and a cookbook for adding a new protocol.
 
 This library is the engine behind
-[Packet-Sniffer](https://github.com/EONRaider/Packet-Sniffer), a
-network traffic monitor built on it.
+[RootWire](https://github.com/EONRaider/RootWire), a network traffic
+monitor built on it (formerly Packet-Sniffer).
 
 ## Roadmap
 
-- IPv6 extension headers (hop-by-hop, routing, fragment, destination
-  options) — today the decode chain ends at `IPv6` for traffic behind
-  them (e.g. MLD).
-- 802.1Q VLAN tags, DNS, DHCP, IGMP, GRE.
-- Checksum computation on encode and verification flags on decode.
-- Fuzzing of the decode path.
+- More protocols: 802.1Q VLAN tags, DHCP, GRE (DNS and IGMP shipped in 1.2).
+- Full DNS resource-record parsing (the header and question are decoded today; answer/authority/additional sections are kept raw).
+- IGMPv3 group-record parsing (the common header is decoded today; v3 report records are kept raw in the body).
+- Optional richer address accessors (`ipaddress` / EUI objects
+  alongside the `str` fields).
+- TLV parsing inside IPv6 extension-header options.
 
 ## Contributing
 
 Development uses [uv](https://docs.astral.sh/uv/): `uv sync`, then
 `uv run pytest`, `uv run mypy`, and `uv run ruff check` — all three are
-enforced by CI on Python 3.12–3.14. Start with
+enforced by CI on Python 3.12–3.14. The test suite is anchored by a
+65-frame corpus of real captured traffic
+([tests/fixtures/MANIFEST.md](tests/fixtures/MANIFEST.md)) plus
+property-based fuzzing of the decode path. Start with
 [ARCHITECTURE.md](ARCHITECTURE.md).
 
 ## License

{netprotocols-1.0.1 → netprotocols-1.2.0}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "netprotocols"
-version = "1.0.1"
+version = "1.2.0"
 description = "Low-level implementations of common networking protocols"
 readme = "README.md"
 license = "MIT"
@@ -29,6 +29,7 @@ Changelog = "https://github.com/EONRaider/NETProtocols/blob/master/CHANGELOG.md"
 
 [dependency-groups]
 dev = [
+    "hypothesis>=6.100",
     "mypy>=1.14",
     "pytest>=8.3",
     "pytest-cov>=6.0",

netprotocols-1.2.0/scripts/capture_fixtures_igmp.sh

@@ -0,0 +1,66 @@
+#!/usr/bin/env bash
+# Capture an IGMP fixture for the corpus (plan item I-2).
+#
+#     sudo scripts/capture_fixtures_igmp.sh
+#
+# IGMP is IPv4 multicast group management — it never appeared in the
+# original corpus (which provoked IPv6 MLD, not IPv4 IGMP). Joining an
+# IPv4 multicast group makes the kernel emit a membership report
+# (IGMPv2 type 0x16 or IGMPv3 type 0x22, depending on the host's
+# configured version); a querier on the LAN may also produce a
+# membership query (type 0x11). This captures `ip proto 2` on the
+# default interface while joining a group, then validates.
+
+set -euo pipefail
+
+if [[ $EUID -ne 0 ]]; then
+    echo "This script needs root for tcpdump (or run it via sudo)." >&2
+    exit 1
+fi
+
+command -v tcpdump >/dev/null || { echo "tcpdump is required." >&2; exit 1; }
+
+OUT="tests/fixtures/staging"
+mkdir -p "$OUT"
+IFACE=$(ip route show default | awk '/default/ {print $5; exit}')
+[[ -n $IFACE ]] || { echo "No default interface found." >&2; exit 1; }
+echo "[*] Default interface: $IFACE"
+
+join_group() {
+    python3 - "$IFACE" <<'PY' || true
+import socket, struct, sys, time
+group = "239.255.42.99"  # an administratively-scoped group (RFC 2365)
+sock = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
+mreq = socket.inet_aton(group) + socket.inet_aton("0.0.0.0")
+sock.setsockopt(socket.IPPROTO_IP, socket.IP_ADD_MEMBERSHIP, mreq)
+time.sleep(3)  # report is emitted on join; hold briefly
+sock.setsockopt(socket.IPPROTO_IP, socket.IP_DROP_MEMBERSHIP, mreq)
+sys.stderr.write(f"joined and left {group} on {sys.argv[1]}\n")
+PY
+}
+
+echo "[>] igmp (join 239.255.42.99 to provoke a membership report)"
+tcpdump -i "$IFACE" -c 4 -w "$OUT/igmp.pcap" --immediate-mode -q \
+    ip proto 2 >/dev/null 2>&1 &
+pid=$!
+sleep 1
+join_group
+for _ in $(seq 15); do kill -0 $pid 2>/dev/null || break; sleep 1; done
+kill $pid 2>/dev/null || true
+wait $pid 2>/dev/null || true
+
+echo
+echo "[*] Validating..."
+CHECKER_PY=$(command -v python3)
+if [[ -n ${SUDO_USER:-} ]]; then
+    chown -R "$SUDO_USER" "$OUT"
+    sudo -u "$SUDO_USER" "$CHECKER_PY" scripts/check_fixtures.py "$OUT"
+else
+    "$CHECKER_PY" scripts/check_fixtures.py "$OUT"
+fi
+
+echo
+echo "[i] If no frames were captured, your host may emit IGMPv3 only when"
+echo "    a querier is present, or multicast may be disabled on $IFACE."
+echo "    The igmp.pcap in staging (if non-empty and OK above) is ready to"
+echo "    fold into the corpus."

{netprotocols-1.0.1 → netprotocols-1.2.0}/scripts/check_fixtures.py

@@ -98,6 +98,14 @@ def check_frame(frame: bytes, stats: Counter) -> list[str]:
                 != struct.unpack_from("!H", upper, 2)[0]
             ):
                 failures.append("icmpv4-checksum")
+        elif proto == 2 and upper_len >= 8:
+            stats["igmp"] += 1
+            # IGMP: whole message, checksum at bytes 2-3, no pseudo-header.
+            if (
+                internet_checksum(upper[:2] + b"\x00\x00" + upper[4:])
+                != struct.unpack_from("!H", upper, 2)[0]
+            ):
+                failures.append("igmp-checksum")
         elif proto == 6 and upper_len >= 20:
             stats["tcp"] += 1
             zeroed = upper[:16] + b"\x00\x00" + upper[18:]
@@ -134,10 +142,13 @@ def check_frame(frame: bytes, stats: Counter) -> list[str]:
             ext_len = (upper[1] + 1) * 8
             next_header, upper = upper[0], upper[ext_len:]
         if next_header == 44 and len(upper) >= 8:
-            stats["ipv6-fragment"] += 1
             if struct.unpack_from("!H", upper, 2)[0] & 0xFFF8:
-                return failures
-            next_header, upper = upper[0], upper[8:]
+                stats["ipv6-fragment"] += 1
+                return failures  # non-first fragment: no upper header
+            stats["ipv6-first-fragment"] += 1
+            # The upper-layer checksum spans the reassembled datagram,
+            # not this fragment's slice: nothing verifiable here.
+            return failures
         upper_len = len(upper)
         if next_header == 58 and upper_len >= 4:
             stats["icmpv6"] += 1

{netprotocols-1.0.1 → netprotocols-1.2.0}/src/netprotocols/__init__.py

@@ -12,12 +12,21 @@ from netprotocols._enums import (
     EtherType,
     IPProtocol,
 )
+from netprotocols.checksum import compute, internet_checksum, verify
 from netprotocols.layer2.arp import ARP
 from netprotocols.layer2.ethernet import Ethernet
 from netprotocols.layer3.icmp import ICMPv4, ICMPv6
+from netprotocols.layer3.igmp import IGMP
 from netprotocols.layer3.ip import IPv4, IPv6
+from netprotocols.layer3.ipv6_ext import (
+    IPv6DestinationOptions,
+    IPv6Fragment,
+    IPv6HopByHopOptions,
+    IPv6Routing,
+)
 from netprotocols.layer4.tcp import TCP
 from netprotocols.layer4.udp import UDP
+from netprotocols.layer7.dns import DNS
 from netprotocols.packet import Packet
 from netprotocols.utils.exceptions import (
     InvalidFieldError,
@@ -30,10 +39,12 @@ from netprotocols.utils.exceptions import (
 from netprotocols.utils.ipv4 import validate_ipv4_addr
 from netprotocols.utils.mac import random_mac, validate_mac_addr
 
-__version__ = "1.0.1"
+__version__ = "1.2.0"
 
 __all__ = [
     "ARP",
+    "DNS",
+    "IGMP",
     "TCP",
     "UDP",
     "ARPHardwareType",
@@ -45,6 +56,10 @@ __all__ = [
     "IPProtocol",
     "IPv4",
     "IPv6",
+    "IPv6DestinationOptions",
+    "IPv6Fragment",
+    "IPv6HopByHopOptions",
+    "IPv6Routing",
     "InvalidFieldError",
     "InvalidIPv4AddressError",
     "InvalidMACAddressError",
@@ -54,7 +69,10 @@ __all__ = [
     "ProtocolError",
     "TruncatedHeaderError",
     "__version__",
+    "compute",
+    "internet_checksum",
     "random_mac",
     "validate_ipv4_addr",
     "validate_mac_addr",
+    "verify",
 ]

{netprotocols-1.0.1 → netprotocols-1.2.0}/src/netprotocols/_enums.py

@@ -36,11 +36,15 @@ class IPProtocol(IntEnum):
     ``next_header``, so a single registry serves both.
     """
 
+    HOPOPT = 0x00
     ICMP = 0x01
     IGMP = 0x02
     TCP = 0x06
     UDP = 0x11
+    IPV6_ROUTE = 0x2B
+    IPV6_FRAG = 0x2C
     IPV6_ICMP = 0x3A
+    IPV6_DSTOPTS = 0x3C
 
     @property
     def display_name(self) -> str:
@@ -48,11 +52,15 @@ class IPProtocol(IntEnum):
 
 
 _IP_PROTOCOL_NAMES = {
+    IPProtocol.HOPOPT: "IPv6 Hop-by-Hop Options",
     IPProtocol.ICMP: "ICMP",
     IPProtocol.IGMP: "IGMP",
     IPProtocol.TCP: "TCP",
     IPProtocol.UDP: "UDP",
+    IPProtocol.IPV6_ROUTE: "IPv6 Routing",
+    IPProtocol.IPV6_FRAG: "IPv6 Fragment",
     IPProtocol.IPV6_ICMP: "IPv6-ICMP",
+    IPProtocol.IPV6_DSTOPTS: "IPv6 Destination Options",
 }