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.
261 lines
9.9 KiB
Python
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
|