"""Exercise generated VPC rules against the real Linux nftables kernel API. Every nft/ip command runs inside a fresh anonymous network namespace. Nothing falls back to the caller's network namespace. Set VIRT_CLOUD_REQUIRE_NFT_KERNEL_TESTS=1 on the supported-host acceptance runner so missing dependencies or capabilities cause failures instead of skips. The packet test additionally needs iproute2 and CAP_NET_RAW. It uses only the Python standard library; namespace exit removes every test link and rule. """ from __future__ import annotations import json import os import shutil import subprocess import sys import pytest from test_vpc_dataplane import _plan as existing_plan from virsh_panel.vpc_dataplane import ( parse_vpc_dataplane_plan, render_vpc_nft_rules, ) def _unavailable(reason: str) -> None: if os.environ.get("VIRT_CLOUD_REQUIRE_NFT_KERNEL_TESTS") == "1": pytest.fail(reason) pytest.skip(reason) @pytest.fixture(scope="module") def nft_namespace(): if sys.platform != "linux": _unavailable("real nftables tests require Linux network namespaces") unshare = shutil.which("unshare") nft = shutil.which("nft") if unshare is None or nft is None: _unavailable("real nftables tests require util-linux unshare and nft") prefix = [unshare, "--net", "--"] probe = subprocess.run( [*prefix, nft, "list", "ruleset"], text=True, capture_output=True, timeout=10, check=False, ) if probe.returncode: message = (probe.stdout + probe.stderr).lower() if "operation not permitted" in message or "permission denied" in message: _unavailable("network namespace/nftables privileges unavailable: " + message) pytest.fail("nftables kernel preflight failed: " + message) return prefix, nft def _topology_plan(topology): original = existing_plan() if topology == "cross_host": return original payload = original.vpc.canonical() payload["operation_id"] = original.vpc.operation_id target_host = "host-a" if topology == "same_host" else "host-b" for member in payload["members"]: member["host_id"] = target_host for host in payload["hosts"]: host["members"] = [ member["member_id"] for member in payload["members"] if member["host_id"] == host["host_id"] ] if topology == "same_host": peers = [] elif topology == "no_local_members": peer = original.peers[0] peers = [{ "host_id": peer.host_id, "public_key": peer.public_key, "overlay_ip": peer.overlay_ip + "/32", "tenant_allowed_ips": sorted({ *(member["private_ip_cidr"] for member in payload["members"]), *(route["destination_cidr"] for route in payload["routes"]), }), }] else: raise AssertionError("unknown test topology") return parse_vpc_dataplane_plan( payload, "host-a", fabric_peers=peers, fabric_plan_digest=original.fabric_plan_digest, ) def _nft_check(namespace, rules): prefix, nft = namespace return subprocess.run( [*prefix, nft, "-c", "-f", "-"], input=rules, text=True, capture_output=True, timeout=15, check=False, ) @pytest.mark.parametrize("topology", ["cross_host", "same_host", "no_local_members"]) def test_complete_vpc_rules_pass_real_nft_check(nft_namespace, topology): plan = _topology_plan(topology) result = _nft_check(nft_namespace, render_vpc_nft_rules(plan)) assert result.returncode == 0, result.stdout + result.stderr def test_real_nft_check_rejects_previous_packet_field_comparison(nft_namespace): rules = render_vpc_nft_rules(_topology_plan("same_host")) fixed = "ether saddr . arp saddr ip != @local_member_sources" broken = "ether saddr != arp saddr ether" assert rules.count(fixed) == 2 valid = _nft_check(nft_namespace, rules) assert valid.returncode == 0, valid.stdout + valid.stderr rejected = _nft_check(nft_namespace, rules.replace(fixed, broken)) assert rejected.returncode != 0, "the old invalid nft expression was accepted" # Run after unshare; subprocesses inherit that one namespace. Keeping the # network setup and packet injector together also makes process exit clean up # all links, counters and rules without modifying global named namespaces. _ARP_KERNEL_PROBE = r''' import json import os import socket import struct import subprocess import sys import time request = json.load(sys.stdin) assert os.readlink("/proc/self/ns/net") != request["parent_netns"], "namespace isolation failed" nft, ip = request["nft"], request["ip"] bridge = request["bridge"] members = request["members"] a, b = members bridge_mac = "02:fe:00:00:00:01" def run(argv, text=None): result = subprocess.run(argv, input=text, capture_output=True, text=True, timeout=10, check=False) if result.returncode: raise AssertionError(repr(argv) + ": " + result.stdout + result.stderr) return result.stdout run([ip, "link", "add", bridge, "type", "bridge"]) run([ip, "link", "set", "dev", bridge, "address", bridge_mac]) for label, member in zip(("a", "b"), members): port, peer = "vc-" + label, "vc-" + label + "-peer" run([ip, "link", "add", port, "type", "veth", "peer", "name", peer]) run([ip, "link", "set", "dev", port, "master", bridge]) run([ip, "link", "set", "dev", peer, "address", member["mac"]]) run([ip, "link", "set", "dev", port, "up"]) run([ip, "link", "set", "dev", peer, "up"]) run([ip, "link", "set", "dev", bridge, "up"]) run([nft, "-c", "-f", "-"], request["rules"]) run([nft, "-f", "-"], request["rules"]) probe = """ table bridge vc_arp_test_probe { counter forward_seen { } counter input_seen { } chain forward { type filter hook forward priority -180; policy accept; meta ibrname "%s" ether type arp counter name forward_seen } chain input { type filter hook input priority -180; policy accept; meta ibrname "%s" ether type arp counter name input_seen } } """ % (bridge, bridge) run([nft, "-f", "-"], probe) def count(hook): payload = json.loads(run([nft, "-j", "list", "counter", "bridge", "vc_arp_test_probe", hook + "_seen"])) counters = [row["counter"]["packets"] for row in payload["nftables"] if "counter" in row] assert len(counters) == 1, payload return counters[0] def mac(value): return bytes.fromhex(value.replace(":", "")) def arp_frame(dst, ethernet_src, arp_src, source_ip): ethernet = mac(dst) + mac(ethernet_src) + struct.pack("!H", 0x0806) arp = struct.pack("!HHBBH", 1, 0x0800, 6, 4, 1) arp += mac(arp_src) + socket.inet_aton(source_ip) arp += bytes(6) + socket.inet_aton(b["ip"]) return (ethernet + arp).ljust(60, b"\0") cases = [ ("member_a", a["mac"], a["mac"], a["ip"], True), ("member_b", b["mac"], b["mac"], b["ip"], True), ("foreign_ethernet", "02:fe:00:00:00:02", a["mac"], a["ip"], False), ("foreign_arp_sha", a["mac"], "02:fe:00:00:00:02", a["ip"], False), ("cross_member_ethernet", b["mac"], a["mac"], a["ip"], False), ("cross_member_arp_sha", a["mac"], b["mac"], a["ip"], False), ("cross_member_pair", b["mac"], b["mac"], a["ip"], False), ("unallocated_source", a["mac"], a["mac"], "10.42.0.99", False), ] with socket.socket(socket.AF_PACKET, socket.SOCK_RAW, socket.htons(0x0806)) as sender: sender.bind(("vc-a-peer", 0)) # Broadcast exercises the forwarding hook even after a spoofed source # teaches the bridge FDB that another member MAC arrived on this port. for hook, dst in (("forward", "ff:ff:ff:ff:ff:ff"), ("input", bridge_mac)): for name, ether_src, arp_src, source_ip, allowed in cases: before = count(hook) sender.send(arp_frame(dst, ether_src, arp_src, source_ip)) # A permitted sentinel after every rejected packet proves that # the bridge processed traffic; a disconnected veth cannot make # all of the rejection cases pass accidentally. if not allowed: sender.send(arp_frame(dst, a["mac"], a["mac"], a["ip"])) deadline = time.monotonic() + 2 while count(hook) < before + 1 and time.monotonic() < deadline: time.sleep(0.01) time.sleep(0.05) after = count(hook) assert after - before == 1, (hook, name, before, after) print(json.dumps({"hooks": ["forward", "input"], "cases_per_hook": len(cases)})) ''' def test_real_bridge_arp_binds_both_source_macs_to_member_ip(nft_namespace): ip = shutil.which("ip") if ip is None: _unavailable("ARP kernel behavior test requires iproute2") prefix, nft = nft_namespace # Distinguish missing raw-socket privileges from an actual assertion or # nft failure in the test. Do not downgrade the latter to a skip. raw_probe = subprocess.run( [*prefix, sys.executable, "-c", "import socket; socket.socket(socket.AF_PACKET, socket.SOCK_RAW, 0).close()"], text=True, capture_output=True, timeout=10, check=False, ) if raw_probe.returncode: if "PermissionError" in raw_probe.stderr: _unavailable("ARP kernel behavior test requires CAP_NET_RAW") pytest.fail("raw socket preflight failed: " + raw_probe.stderr) plan = _topology_plan("same_host") request = { "nft": nft, "ip": ip, "parent_netns": os.readlink("/proc/self/ns/net"), "bridge": plan.resources.bridge, "members": [{"mac": m.private_mac, "ip": m.private_ip} for m in plan.local_members], "rules": render_vpc_nft_rules(plan), } result = subprocess.run( [*prefix, sys.executable, "-c", _ARP_KERNEL_PROBE], input=json.dumps(request), text=True, capture_output=True, timeout=45, check=False, ) assert result.returncode == 0, result.stdout + result.stderr assert json.loads(result.stdout)["cases_per_hook"] == 8