You cannot select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
virt/engine/tests/test_vpc_nft_kernel.py

261 lines
9.9 KiB
Python

"""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